@scriptc/compiler 0.1.3 → 0.1.4

package/dist/ir/validate.js

@@ -246,6 +246,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 +261,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 +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 },
@@ -303,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 },
@@ -323,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 },
@@ -445,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 },
@@ -462,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 },
@@ -475,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).
@@ -484,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
@@ -678,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 },
@@ -693,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.
@@ -734,7 +783,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 +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,
@@ -825,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 } },
@@ -851,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 },
@@ -869,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 },
@@ -921,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 },
@@ -1035,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.
@@ -1139,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 },
@@ -1817,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);
@@ -1855,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" ||
@@ -2859,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 &&
@@ -3764,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" ||
@@ -4121,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 &&
@@ -4133,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" ||
@@ -4231,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") {
@@ -4286,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 &&
@@ -4301,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;
                 }
@@ -4341,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 &&
@@ -4789,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") {
@@ -4836,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)) {