@scriptc/compiler 0.1.2 → 0.1.4

package/dist/ir/validate.js

@@ -1,4 +1,5 @@
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
+import { BIGINT_T } from "./ir.js";
 /** Per-method signature for strIntrinsic: `argTypes` lists every argument
  * position (optional ones included); `minArgs` is how many may be omitted
  * from the end (backends fill the documented defaults). Exported for the
@@ -229,10 +230,43 @@ export const LIB_FN_SIGS = {
     "sym.keyFor": { argTypes: [SYMBOL_T], result: VOID },
     "sym.desc": { argTypes: [SYMBOL_T], result: VOID },
     "sym.toString": { argTypes: [SYMBOL_T], result: STRING },
+    "bigint.parse": { argTypes: [STRING], result: BIGINT_T },
+    "bigint.fromF64": { argTypes: [F64], result: BIGINT_T },
+    "bigint.neg": { argTypes: [BIGINT_T], result: BIGINT_T },
+    "bigint.not": { argTypes: [BIGINT_T], result: BIGINT_T },
+    "bigint.add": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.sub": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.mul": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.div": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.mod": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.pow": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.and": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.or": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "bigint.xor": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
+    "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 },
+    "bigint.toString": { argTypes: [BIGINT_T, F64], result: STRING },
+    "bigint.inspect": { argTypes: [BIGINT_T], result: STRING },
+    "bigint.toF64": { argTypes: [BIGINT_T], result: F64 },
+    "bigint.asUintN": { argTypes: [F64, BIGINT_T], result: BIGINT_T },
+    "bigint.asIntN": { argTypes: [F64, BIGINT_T], result: BIGINT_T },
+    "bigint.bufferRead": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: BIGINT_T },
+    "bigint.bufferWrite": { argTypes: [BYTES_U8, BIGINT_T, F64, BOOL, BOOL], result: F64 },
+    "bigint.dataViewGet": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: BIGINT_T },
+    "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 },
@@ -248,6 +282,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 },
@@ -274,7 +309,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 },
@@ -294,10 +334,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 },
@@ -416,6 +459,7 @@ export const LIB_FN_SIGS = {
     "http.createServer": { argTypes: [null], result: NETSERVER_T },
     "http.createServerEmpty": { argTypes: [], result: NETSERVER_T },
     "http.serverJoinDupHeaders": { argTypes: [NETSERVER_T], result: VOID },
+    "http.serverAllowMissingHostHeader": { argTypes: [NETSERVER_T], result: VOID },
     "http.serverTimeoutGet": { argTypes: [NETSERVER_T, F64], result: F64 },
     "http.serverTimeoutSet": { argTypes: [NETSERVER_T, F64, F64], result: VOID },
     "http.serverTimeoutOptionSet": { argTypes: [NETSERVER_T, F64, DYN], result: VOID },
@@ -433,6 +477,9 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -446,6 +493,11 @@ 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.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).
@@ -455,6 +507,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
@@ -649,6 +703,11 @@ export const LIB_FN_SIGS = {
     "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.clientDestroy": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
     "http.clientDestroyed": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
     "http.clientOnResponse": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
@@ -664,17 +723,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.
@@ -700,11 +778,22 @@ export const LIB_FN_SIGS = {
     // case checks the arms — the child.pid pattern with a ref arm).
     "child.stdout": { argTypes: [CHILD_T], result: VOID },
     "child.stderr": { argTypes: [CHILD_T], result: VOID },
+    "child.stdin": { argTypes: [CHILD_T], result: VOID },
     // Listener registrations: callback func shapes are program-dependent
     // (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 },
+    "writer.destroy": { argTypes: [CHILDWRITER_T], result: VOID },
+    "writer.writable": { argTypes: [CHILDWRITER_T], result: BOOL },
+    "writer.onDrain": { argTypes: [CHILDWRITER_T, null, BOOL], result: VOID },
+    "writer.onFinish": { argTypes: [CHILDWRITER_T, null, BOOL], result: VOID },
+    "writer.onError": { argTypes: [CHILDWRITER_T, null, BOOL], result: VOID },
     "procStream.write": { argTypes: [PROCSTREAM_T, STRING], result: BOOL },
     "child.killed": { argTypes: [CHILD_T], result: BOOL },
     "child.kill": { argTypes: [CHILD_T, STRING], result: BOOL },
@@ -717,6 +806,25 @@ export const LIB_FN_SIGS = {
     "crypto.randomBytes": { argTypes: [F64], result: BYTES_U8 },
     "crypto.hashDigestStr": { argTypes: [STRING, STRING, STRING], result: STRING },
     "crypto.hashDigestBytes": { argTypes: [STRING, BYTES_U8, STRING], result: STRING },
+    "crypto.hashNew": { argTypes: [STRING], result: CRYPTOHASH_T },
+    "crypto.hmacNewStr": { argTypes: [STRING, STRING], result: CRYPTOHMAC_T },
+    "crypto.hmacNewBytes": { argTypes: [STRING, BYTES_U8], result: CRYPTOHMAC_T },
+    "crypto.hashUpdateStr": { argTypes: [CRYPTOHASH_T, STRING], result: CRYPTOHASH_T },
+    "crypto.hashUpdateBytes": { argTypes: [CRYPTOHASH_T, BYTES_U8], result: CRYPTOHASH_T },
+    "crypto.hmacUpdateStr": { argTypes: [CRYPTOHMAC_T, STRING], result: CRYPTOHMAC_T },
+    "crypto.hmacUpdateBytes": { argTypes: [CRYPTOHMAC_T, BYTES_U8], result: CRYPTOHMAC_T },
+    "crypto.hashCopy": { argTypes: [CRYPTOHASH_T], result: CRYPTOHASH_T },
+    "crypto.hashDigestString": { argTypes: [CRYPTOHASH_T, STRING], result: STRING },
+    "crypto.hashDigestBuffer": { argTypes: [CRYPTOHASH_T], result: BYTES_U8 },
+    "crypto.hmacDigestString": { argTypes: [CRYPTOHMAC_T, STRING], result: STRING },
+    "crypto.hmacDigestBuffer": { argTypes: [CRYPTOHMAC_T], result: BYTES_U8 },
+    "crypto.timingSafeEqual": { argTypes: [BYTES_U8, BYTES_U8], result: BOOL },
+    "crypto.randomFill": { argTypes: [BYTES_U8, F64, F64], result: BYTES_U8 },
+    "crypto.randomFillRest": { argTypes: [BYTES_U8, F64], result: BYTES_U8 },
+    "crypto.randomInt": { argTypes: [F64, F64], result: F64 },
+    "crypto.pbkdf2": { argTypes: [BYTES_U8, BYTES_U8, F64, F64, STRING], result: BYTES_U8 },
+    "crypto.randomBytesCb": { argTypes: [F64, null], result: VOID },
+    "crypto.pbkdf2Cb": { argTypes: [BYTES_U8, BYTES_U8, F64, F64, STRING, null], result: VOID },
     // The Buffer statics and the fs/zlib Buffer forms: fixed always-u8
     // signatures (Buffer IS a Uint8Array — one bytes kind).
     "buffer.fromStr": { argTypes: [STRING, STRING], result: BYTES_U8 },
@@ -751,6 +859,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,
@@ -768,8 +889,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 } },
@@ -794,6 +920,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 },
@@ -812,6 +940,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 },
@@ -864,9 +993,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 },
@@ -960,6 +1091,7 @@ export const LIB_FN_SIGS = {
     // message slot always carries a string ("" when hasMsg is false).
     "assert.ok": { argTypes: [BOOL, STRING], result: VOID },
     "assert.eqF64": { argTypes: [F64, F64, BOOL, BOOL, STRING, BOOL], result: VOID },
+    "assert.eqBigInt": { argTypes: [BIGINT_T, BIGINT_T, BOOL, BOOL, STRING, BOOL], result: VOID },
     "assert.eqStr": { argTypes: [STRING, STRING, BOOL, BOOL, STRING, BOOL], result: VOID },
     "assert.eqBool": { argTypes: [BOOL, BOOL, BOOL, BOOL, STRING, BOOL], result: VOID },
     "assert.deepResult": { argTypes: [BOOL, BOOL, STRING, BOOL], result: VOID },
@@ -977,6 +1109,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.
@@ -1081,6 +1214,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 },
@@ -1759,6 +1893,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);
@@ -1797,6 +1936,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" ||
@@ -1954,9 +2098,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 checkExpr(e.operand);
                 if (e.operand.type.kind !== "f64" &&
                     e.operand.type.kind !== "string" &&
+                    e.operand.type.kind !== "dyn" &&
                     e.operand.type.kind !== "union" &&
                     !REF_TRUTHY_KINDS.has(e.operand.type.kind)) {
-                    err(`toBool operand must be f64|string|union|ref, got ${e.operand.type.kind}`, e.loc);
+                    err(`toBool operand must be f64|string|dyn|union|ref, got ${e.operand.type.kind}`, e.loc);
                 }
                 if (e.operand.type.kind === "union")
                     checkTruthyUnion(e.operand.type.unionId, e.loc);
@@ -2800,7 +2945,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 &&
@@ -3705,7 +3850,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" ||
@@ -4062,7 +4207,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") {
                     // Result is the interned `string | undefined` union (envGet's).
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     const ok = def &&
@@ -4074,6 +4219,15 @@ 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 === "net.sockOnData" || e.fn === "net.serverOnError" ||
@@ -4172,6 +4326,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") {
@@ -4227,12 +4405,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 &&
@@ -4242,7 +4423,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;
                 }
@@ -4282,18 +4463,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 &&
@@ -4319,6 +4525,18 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
+                if (e.fn === "writer.onDrain" || e.fn === "writer.onFinish" || e.fn === "writer.onError") {
+                    const cbT = e.args[1]?.type;
+                    const maxParams = e.fn === "writer.onError" ? 1 : 0;
+                    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];
+                        ok = p.kind === "object" && p.className === "%Error";
+                    }
+                    if (!ok)
+                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+                    break;
+                }
                 if (e.fn === "process.onExit" || e.fn === "process.offExit" ||
                     e.fn === "stdin.onData" || e.fn === "stdin.onError") {
                     // The listener: a void closure with no params, or exactly the
@@ -4438,14 +4656,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
-                if (e.fn === "child.stdout" || e.fn === "child.stderr") {
+                if (e.fn === "child.stdin" || e.fn === "child.stdout" || e.fn === "child.stderr") {
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+                    const handleKind = e.fn === "child.stdin" ? "childWriter" : "childStream";
                     const ok = def &&
                         def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "childStream") &&
+                        def.arms.some((a) => a.kind === handleKind) &&
                         def.arms.some((a) => a.kind === "nullT");
                     if (!ok) {
-                        err(`libCall ${e.fn} must return the 'Readable | null' union`, e.loc);
+                        err(`libCall ${e.fn} must return the '${e.fn === "child.stdin" ? "Writable" : "Readable"} | null' union`, e.loc);
                     }
                     break;
                 }
@@ -4717,7 +4936,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") {
@@ -4764,7 +4983,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)) {