@scriptc/compiler 0.3.3 → 0.3.5

package/dist/ir/builtin-signatures.js

@@ -1,5 +1,5 @@
 import { BIGINT_T } from "./ir.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DIR_T, DGRAMSOCK_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REGEX, SEARCH_PARAMS_T, SECURECTX_T, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, URL_T, VOID, } from "./ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DIR_T, DGRAMSOCK_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REGEX, SEARCH_PARAMS_T, SECURECTX_T, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, URL_T, VOID, funcOf, } from "./ir.js";
 /** Preserve the closed names while giving every entry the same slot type. */
 function defineLibFnSignatures(signatures) {
     return signatures;
@@ -1277,6 +1277,22 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "dgram.unref": { argTypes: [DGRAMSOCK_T], result: VOID },
     "dgram.ref": { argTypes: [DGRAMSOCK_T], result: VOID },
+    /** The socket options (scr_dgram.c): the membership calls take the
+     * interface and whether it was given. May-throw. */
+    "dgram.setBroadcast": { argTypes: [DGRAMSOCK_T, BOOL], result: VOID },
+    "dgram.setTTL": { argTypes: [DGRAMSOCK_T, F64], result: F64 },
+    "dgram.setMulticastTTL": { argTypes: [DGRAMSOCK_T, F64], result: F64 },
+    "dgram.setMulticastLoopback": { argTypes: [DGRAMSOCK_T, BOOL], result: BOOL },
+    "dgram.setMulticastInterface": { argTypes: [DGRAMSOCK_T, STRING], result: VOID },
+    "dgram.addMembership": { argTypes: [DGRAMSOCK_T, STRING, STRING, BOOL], result: VOID },
+    "dgram.dropMembership": { argTypes: [DGRAMSOCK_T, STRING, STRING, BOOL], result: VOID },
+    "dgram.getRecvBufferSize": { argTypes: [DGRAMSOCK_T], result: F64 },
+    "dgram.getSendBufferSize": { argTypes: [DGRAMSOCK_T], result: F64 },
+    "dgram.setRecvBufferSize": { argTypes: [DGRAMSOCK_T, F64], result: VOID },
+    "dgram.setSendBufferSize": { argTypes: [DGRAMSOCK_T, F64], result: VOID },
+    "dgram.getSendQueueSize": { argTypes: [DGRAMSOCK_T], result: F64 },
+    "dgram.getSendQueueCount": { argTypes: [DGRAMSOCK_T], result: F64 },
+    "dgram.disconnect": { argTypes: [DGRAMSOCK_T], result: VOID },
     "dgram.onMessage": { argTypes: [DGRAMSOCK_T, null, BOOL], result: VOID },
     "dgram.onError": { argTypes: [DGRAMSOCK_T, null, BOOL], result: VOID },
     "dgram.onListening": {
@@ -1292,6 +1308,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         result: VOID,
     },
     "dns.lookup": { argTypes: [STRING, F64, null], result: VOID },
+    /** Node's argument forms with dyn callbacks: lookup(hostname, options,
+     * callback) and lookupService(address, port, callback). */
+    "dns.lookupDyn": { argTypes: [DYN, DYN, DYN, BOOL], result: VOID },
+    "dns.lookupService": { argTypes: [DYN, DYN, DYN, BOOL], result: VOID },
+    "dns.getServers": { argTypes: [], result: DYN },
+    "dns.getDefaultResultOrder": { argTypes: [], result: STRING },
+    "dns.setDefaultResultOrder": { argTypes: [DYN], result: VOID },
     // node:test (scr_test.c). Bodies are program-dependent closures (0 or
     // 1 testCtx param, void or Promise<void> result — the spoke pinned the
     // shape): null slots. sub's result is the settled Promise<void> the
@@ -1311,7 +1334,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "test.register": { argTypes: [STRING, F64, STRING, null, F64, STRING], result: VOID },
     "test.registerEmpty": { argTypes: [STRING, F64, STRING, F64, STRING], result: VOID },
     "test.suite": {
-        argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING],
+        argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING, F64],
         result: VOID,
     },
     "test.hook": { argTypes: [F64, null, F64], result: VOID },
@@ -1324,6 +1347,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "test.ctxTodo": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxDiagnostic": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxName": { argTypes: [TESTCTX_T], result: STRING },
+    "test.ctxFullName": { argTypes: [TESTCTX_T], result: STRING },
+    // t.before/t.after/t.beforeEach/t.afterEach (which: 0 before, 1 after,
+    // 2 beforeEach, 3 afterEach); a throwing t.before is captured on the test.
+    "test.ctxHook": { argTypes: [TESTCTX_T, F64, null, F64], result: VOID },
+    // t.plan(count), and the count of one t.assert call.
+    "test.ctxPlan": { argTypes: [TESTCTX_T, F64], result: VOID },
+    "test.ctxCount": { argTypes: [TESTCTX_T], result: VOID },
     // node:http (scr_http.c over scr_net.c). The handler and the data
     // listeners are program-dependent closures (null slots, checked in the
     // libCall case); reqHeader's result is the interned string|undefined
@@ -1393,6 +1423,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     // resGetHeader answers the interned `string | undefined` union — the
     // reqHeader/envGet sentinel pattern (VOID here, checked specially).
     "http.resGetHeader": { argTypes: [HTTPRES_T, STRING], result: VOID },
+    /** getHeader as Node answers it: the number, string or string[] that was
+     * set, or undefined, as a checked-dynamic value. */
+    "http.resGetHeaderDyn": { argTypes: [HTTPRES_T, STRING], result: DYN },
     "http.resGetHeaderNames": { argTypes: [HTTPRES_T], result: arrayOf(STRING) },
     "http.resGetRawHeaderNames": { argTypes: [HTTPRES_T], result: arrayOf(STRING) },
     "http.resGetHeaders": { argTypes: [HTTPRES_T], result: DYN },
@@ -1418,6 +1451,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         result: VOID,
     },
     "http.resSetHeader": { argTypes: [HTTPRES_T, STRING, STRING], result: VOID },
+    /** setHeader / appendHeader with a number, string or array value; the
+     * stored value keeps its type for getHeader/getHeaders. MAY THROW. */
+    "http.resSetHeaderDyn": { argTypes: [HTTPRES_T, STRING, DYN], result: VOID },
+    "http.resAppendHeader": { argTypes: [HTTPRES_T, STRING, DYN], result: VOID },
     "http.resWriteHead": { argTypes: [HTTPRES_T, F64], result: VOID },
     "http.resWriteHeadN": {
         argTypes: [HTTPRES_T, F64, arrayOf(STRING), arrayOf(STRING)],
@@ -1476,6 +1513,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * ...] pairs in arrival order — the interned %headers.snapshot helper
      * builds the record over it, exactly the process.envPairs pattern. */
     "http.reqHeaderPairs": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
+    /** Every value of one header in arrival order (empty when absent): the
+     * set-cookie array of a `{ ...req.headers }` snapshot. */
+    "http.reqHeaderList": { argTypes: [HTTPREQ_T, STRING], 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 },
@@ -1636,7 +1676,45 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "net.sockResume": { argTypes: [NETSOCKET_T], result: NETSOCKET_T },
     "net.sockSetNoDelay": { argTypes: [NETSOCKET_T, BOOL], result: NETSOCKET_T },
     "net.sockDestroySoon": { argTypes: [NETSOCKET_T], result: VOID },
+    /** RST close, answers the socket; throws ERR_INVALID_HANDLE_TYPE on TLS. */
+    "net.sockResetAndDestroy": { argTypes: [NETSOCKET_T], result: NETSOCKET_T },
+    /** socket.address(): { address, family, port } or {} as a dyn. */
+    "net.sockAddress": { argTypes: [NETSOCKET_T], result: DYN },
     "net.sockBytesWritten": { argTypes: [NETSOCKET_T], result: F64 },
+    /** remotePort (0), remoteFamily (1), localAddress (2), localPort (3),
+     * localFamily (4): dyn values, undefined when unknown. */
+    "net.sockAddrField": { argTypes: [NETSOCKET_T, F64], result: DYN },
+    "net.sockBytesRead": { argTypes: [NETSOCKET_T], result: F64 },
+    "net.sockConnecting": { argTypes: [NETSOCKET_T], result: BOOL },
+    "net.sockPending": { argTypes: [NETSOCKET_T], result: BOOL },
+    "net.sockReadyState": { argTypes: [NETSOCKET_T], result: STRING },
+    "net.sockSetKeepAlive": { argTypes: [NETSOCKET_T, BOOL, F64], result: NETSOCKET_T },
+    "net.sockOnReady": {
+        argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL],
+        result: VOID,
+    },
+    /** Listeners with a parameter, as dyn functions: close(hadError),
+     * write's cb(err) and end's cb. */
+    "net.sockOnCloseDyn": { argTypes: [NETSOCKET_T, DYN, BOOL], result: VOID },
+    "net.sockOnWriteFlush": {
+        argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }],
+        result: VOID,
+    },
+    "net.sockOnWriteFlushDyn": { argTypes: [NETSOCKET_T, DYN], result: VOID },
+    "net.sockOnFinishDyn": { argTypes: [NETSOCKET_T, DYN], result: VOID },
+    "net.sockSetTimeoutCb": {
+        argTypes: [NETSOCKET_T, F64, { kind: "func", params: [], ret: VOID }],
+        result: VOID,
+    },
+    "net.isIP": { argTypes: [DYN], result: F64 },
+    "net.isIPv4": { argTypes: [DYN], result: BOOL },
+    "net.isIPv6": { argTypes: [DYN], result: BOOL },
+    "net.serverMaxConnectionsGet": { argTypes: [NETSERVER_T], result: DYN },
+    "net.serverMaxConnectionsSet": { argTypes: [NETSERVER_T, DYN], result: VOID },
+    "net.serverDropMaxConnectionGet": { argTypes: [NETSERVER_T], result: DYN },
+    "net.serverDropMaxConnectionSet": { argTypes: [NETSERVER_T, DYN], result: VOID },
+    "net.serverOnDrop": { argTypes: [NETSERVER_T, DYN, BOOL], result: VOID },
+    "net.serverGetConnections": { argTypes: [NETSERVER_T, DYN], result: VOID },
     "net.sockReadable": { argTypes: [NETSOCKET_T], result: BOOL },
     /** socket.on('finish', cb) / end(cb): fires once when the FIN goes out
      * (sweep-deferred, never the registering stack). */
@@ -1712,6 +1790,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * the 'session' registration (fires once with the serialized session —
      * a Buffer; the received-ticket event). */
     "tls.sockAuthorized": { argTypes: [NETSOCKET_T], result: BOOL },
+    /** getProtocol() (string | null), getCipher() (CipherNameAndProtocol,
+     * undefined before the handshake, null after close) and alpnProtocol
+     * (string | false | null), as dyn values. */
+    "tls.sockGetProtocol": { argTypes: [NETSOCKET_T], result: DYN },
+    "tls.sockGetCipher": { argTypes: [NETSOCKET_T], result: DYN },
+    "tls.sockAlpnProtocol": { argTypes: [NETSOCKET_T], result: DYN },
     "tls.sockAuthError": { argTypes: [NETSOCKET_T], result: VOID },
     "tls.sockOnSecureConnect": {
         argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL],
@@ -2017,17 +2101,19 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         ],
         result: STRING,
     },
-    /** The promisified-execFile capture (args: cmd, argv, cwd, hasEnv,
-     * envPairs, timeoutMs): the same exec core in the async shape — both
-     * streams captured, no echo, Node's ASYNC messages on the throw paths
+    /** The promisified-execFile/exec capture (args: cmd, argv, shell, cwd,
+     * hasEnv, envPairs, timeoutMs; shell marks exec's /bin/sh -c argv, as
+     * for execSync, so failures display the command string): the same exec
+     * core in the async shape — both streams captured, no echo, Node's ASYNC messages on the throw paths
      * ("Command failed: <cmd>\n<stderr>" with the unconditional newline,
      * "spawn <file> ENOENT" with .code, timeouts reporting as ordinary
      * SIGTERM command failures — never ETIMEDOUT). Result reuses the
      * ScrSpawnRes container (+1; stdout/stderr strings, status unused).
-     * Called only from the frontend's interned %execFileAsync ASYNC helper,
-     * whose fiber turns the throw into the rejection. */
+     * Called only from the frontend's interned %execFileAsync and
+     * %execAsync ASYNC helpers, whose fiber turns the throw into the
+     * rejection. */
     "cp.execCapture": {
-        argTypes: [STRING, arrayOf(STRING), STRING, BOOL, arrayOf(STRING), F64],
+        argTypes: [STRING, arrayOf(STRING), BOOL, STRING, BOOL, arrayOf(STRING), F64],
         result: SPAWNRES_T,
     },
     /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawnp
@@ -2250,6 +2336,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * finalizes the handle and returns either a Buffer or encoded string. */
     "crypto.native": { argTypes: [], result: DYN },
     "crypto.hashNew": { argTypes: [STRING], result: CRYPTOHASH_T },
+    /** createCipheriv (false) / createDecipheriv (true) over checked-dynamic
+     * cipher, key, iv and options arguments (scr_cipher.c): a native
+     * Cipheriv/Decipheriv handle whose methods dispatch through dynInvoke. */
+    "crypto.cipherNew": { argTypes: [BOOL, DYN, DYN, DYN, DYN], result: DYN },
     "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 },
@@ -2326,6 +2416,22 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * opaque reference inputs retain explicit runtime refusals. */
     "buffer.fromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
     "buffer.concat": { argTypes: [arrayOf(BYTES_U8)], result: BYTES_U8 },
+    /** The pooled Buffer factories (Node's allocate/fromStringFast/
+     * fromArrayLike): allocUnsafe, Buffer.from of strings, Uint8Arrays,
+     * number[] and checked values, and concat return views into the
+     * per-thread pool slab below Buffer.poolSize >>> 1 bytes. alloc and
+     * allocUnsafeSlow never pool. The size forms validate like Node
+     * (ERR_OUT_OF_RANGE). poolSize reads and writes Buffer.poolSize. */
+    "buffer.alloc": { argTypes: [F64], result: BYTES_U8 },
+    "buffer.allocUnsafe": { argTypes: [F64], result: BYTES_U8 },
+    "buffer.allocUnsafeSlow": { argTypes: [F64], result: BYTES_U8 },
+    "buffer.poolFromStr": { argTypes: [STRING, STRING], result: BYTES_U8 },
+    "buffer.poolFromStrChecked": { argTypes: [STRING, STRING], result: BYTES_U8 },
+    "buffer.poolFromBytes": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "buffer.poolFromArray": { argTypes: [arrayOf(F64)], result: BYTES_U8 },
+    "buffer.poolFromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
+    "buffer.poolSize": { argTypes: [], result: F64 },
+    "buffer.setPoolSize": { argTypes: [F64], result: VOID },
     /** Buffer.byteLength(string, enc) — enc a NORMALIZED literal like
      * fromStr's — and Buffer.isEncoding(name) over a runtime string
      * (case-insensitive against Node's alias set). Pure; never throw. */
@@ -2379,6 +2485,32 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fsp.lchmodChk": { argTypes: [DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fs.readChk": { argTypes: [DYN, DYN, DYN, DYN, DYN, STRING], result: VOID },
     "fs.streamOptsChk": { argTypes: [DYN, DYN, STRING], result: VOID },
+    /** fs.ReadStream / fs.WriteStream (scr_fs_stream.c): the constructors
+     * take the path and options as dyn values and throw Node's option
+     * errors; the members read bytesRead/bytesWritten, pending and the path
+     * value, and close() / close(cb) (a `() => void` callback). */
+    "fs.createReadStream": {
+        argTypes: [DYN, DYN],
+        result: { kind: "object", className: "%Readable" },
+    },
+    "fs.createWriteStream": {
+        argTypes: [DYN, DYN],
+        result: { kind: "object", className: "%Writable" },
+    },
+    "fs.fsStreamBytes": { argTypes: [null], result: F64 },
+    "fs.fsStreamPending": { argTypes: [null], result: BOOL },
+    "fs.fsStreamPath": { argTypes: [null], result: DYN },
+    "fs.fsStreamPropDyn": { argTypes: [null, STRING], result: DYN },
+    "fileHandle.createReadStream": {
+        argTypes: [FILEHANDLE_T, DYN],
+        result: { kind: "object", className: "%Readable" },
+    },
+    "fileHandle.createWriteStream": {
+        argTypes: [FILEHANDLE_T, DYN],
+        result: { kind: "object", className: "%Writable" },
+    },
+    "fs.fsStreamClose": { argTypes: [null], result: VOID },
+    "fs.fsStreamCloseCb": { argTypes: [null, funcOf([], VOID)], result: VOID },
     /** The compiler-resolved ERR_INVALID_ARG_TYPE throw with a RUNTIME-
      * rendered Received tail: args [argname, "of type ..." clause, the
      * offending dyn value]. ALWAYS THROWS; polymorphic result (the
@@ -2431,6 +2563,21 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "zlib.gunzipCb": { argTypes: [BYTES_U8, null], result: VOID },
     "zlib.unzipCb": { argTypes: [BYTES_U8, null], result: VOID },
     "zlib.crc32": { argTypes: [BYTES_U8, F64], result: F64 },
+    /** The stream classes (scr_zlib_stream.c, linked with the stream unit):
+     * streamNew takes Node's node_zlib_mode number and the options value
+     * (undefined when absent), validates it with Node's ladder, and answers
+     * the +1 %Transform stream. flush takes the kind value, params the level
+     * and strategy values; the Cb forms move their () => void callback. The
+     * receivers are borrowed. */
+    "zlib.streamNew": { argTypes: [F64, DYN], result: VOID },
+    "zlib.streamBytesWritten": { argTypes: [null], result: F64 },
+    "zlib.streamFlush": { argTypes: [null, DYN], result: VOID },
+    "zlib.streamFlushCb": { argTypes: [null, DYN, null], result: VOID },
+    "zlib.streamParams": { argTypes: [null, DYN, DYN], result: VOID },
+    "zlib.streamParamsCb": { argTypes: [null, DYN, DYN, null], result: VOID },
+    "zlib.streamClose": { argTypes: [null], result: VOID },
+    "zlib.streamCloseCb": { argTypes: [null, null], result: VOID },
+    "zlib.streamReset": { argTypes: [null], result: VOID },
     /** The Buffer overloads of the raw stream writes — same promptly
      * submitted streams as process.stdoutWrite/stderrWrite, constantly true.
      * The encoding arg is evaluated but ignored for bytes, like Node. The Cb
@@ -2957,6 +3104,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * lowered directly (the list's values need no dyn representation to
      * fail). */
     "dyn.cloneTransferFail": { argTypes: [], result: DYN },
+    /** The same refusal given the transfer list's first member, an
+     * ArrayBuffer: a Buffer pool slab gets Node's untransferable message. */
+    "dyn.cloneTransferFailWith": { argTypes: [DYN], result: DYN },
     /** `new RegExp(pattern, flags?)` (scr_regex.c): a heap regex over the
      * same libregexp engine the literals use. The pattern compiles EAGERLY
      * so an invalid pattern (or an unknown flag letter) throws Node's
@@ -3118,6 +3268,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stream.finishedDyn": { argTypes: [null, DYN], result: VOID },
     "stream.pipeline": { argTypes: [F64], result: VOID },
     "stream.pipelineDyn": { argTypes: [F64], result: VOID },
+    "stream.pipelineStages": { argTypes: [F64, F64, F64, F64, F64], result: VOID },
+    "stream.pipelineStagesDyn": { argTypes: [F64, F64, F64, F64, F64], result: VOID },
+    /** stream.compose(count, s1..sn): the Duplex over a pipeline of the
+     * streams (+1). MAY THROW (ERR_INVALID_ARG_VALUE for a stream that is
+     * no longer readable or writable). */
+    "stream.compose": { argTypes: [F64], result: VOID },
     /** node:stream/promises — the promise forms over the same machinery:
      * sp.finished: (s) → a pending void promise the terminal watcher
      * settles; sp.pipeline: (count, s1..sn) → the callback pipeline's
@@ -3144,6 +3300,18 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stream.finishedOpts": { argTypes: [null, F64, F64, BOOL, null], result: VOID },
     "stream.finishedOptsSignal": { argTypes: [null, F64, F64, BOOL, DYN, null], result: VOID },
     "sp.pipeline": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
+    /** pipeline with a run of function stages: [n, at, k, flags, mask,
+     * s1..sn, stage1..stagek, (next, read, return)?, box?, (signal,
+     * abort)?] (+ the callback for the stream.* forms): the user's stage
+     * functions, the frontend's helpers over the pumped generator or a
+     * promise destination's box, and the pipeline's AbortSignal with its
+     * abort closure; flags names which groups are present
+     * (scr_stream_pipeline_stages). A promise destination's promise type is
+     * sp.pipelineStages' result. */
+    "sp.pipelineStages": {
+        argTypes: [F64, F64, F64, F64, F64],
+        result: { kind: "promise", inner: VOID },
+    },
     /** node:stream/consumers — the promise consumers over the readable
      * machinery: (s) → a pending promise settled at the terminal point
      * with the accumulated result (sc.text: the utf8 decode, sc.json: the
@@ -3200,11 +3368,40 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * +1 promise of the next chunk — buffered content, the EOF sentinel
      * (empty Buffer / dyn undefined), or a rejection with the stream's
      * error. The Dyn twin boxes chunks by runtime tag (the JS lane).
-     * readable.fromArr is Readable.from(array): a fully-seeded object-
-     * entry stream (one whole chunk per element; strings per the flag). */
+     * readable.fromArr is Readable.from over a typed array, string or
+     * Buffer: [array, SCR_FROM_* flags, highWaterMark]. readable.fromDyn is
+     * the JS lane's [source, options]. */
     "readable.nextChunk": { argTypes: [null], result: VOID },
     "readable.nextChunkDyn": { argTypes: [null], result: VOID },
-    "readable.fromArr": { argTypes: [null, BOOL], result: VOID },
+    "readable.fromArr": { argTypes: [null, F64, F64], result: VOID },
+    "readable.fromDyn": { argTypes: [DYN, DYN], result: VOID },
+    /** Readable.from over a compiled generator: [generator, next, return,
+     * throw, flags, highWaterMark] (sync) or [generator, next, read,
+     * return, throw, flags, highWaterMark] (async), the helpers being the
+     * frontend's interned closures. readable.fromDone is the done marker
+     * the helpers answer. */
+    "readable.fromGen": { argTypes: [null, null, null, null, F64, F64], result: VOID },
+    "readable.fromAsyncGen": { argTypes: [null, null, null, null, null, F64, F64], result: VOID },
+    "readable.fromDone": { argTypes: [], result: DYN },
+    /** The Readable operators (scr_stream_ops.c): [stream, ...] with every
+     * other argument a checked-dynamic value (the callback, the count, the
+     * options). map/filter/flatMap/drop/take answer the object-mode output
+     * stream (validated as a stream class; THROW Node's validation errors);
+     * toArray settles a dyn array, find a dyn value, some/every a boolean,
+     * forEach nothing; reduce: [stream, fn, init, hasInit, options, kind]
+     * with the payload kind (0 dyn, 1 number, 2 boolean, 3 string). The
+     * promise-returning ones reject instead of throwing. */
+    "readable.opMap": { argTypes: [null, DYN, DYN], result: VOID },
+    "readable.opFilter": { argTypes: [null, DYN, DYN], result: VOID },
+    "readable.opFlatMap": { argTypes: [null, DYN, DYN], result: VOID },
+    "readable.opDrop": { argTypes: [null, DYN, DYN], result: VOID },
+    "readable.opTake": { argTypes: [null, DYN, DYN], result: VOID },
+    "readable.opToArray": { argTypes: [null, DYN], result: { kind: "promise", inner: DYN } },
+    "readable.opForEach": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: VOID } },
+    "readable.opSome": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: BOOL } },
+    "readable.opEvery": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: BOOL } },
+    "readable.opFind": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "readable.opReduce": { argTypes: [null, DYN, DYN, BOOL, DYN, F64], result: VOID },
     "readable.resume": { argTypes: [null], result: VOID },
     "readable.isPaused": { argTypes: [null], result: BOOL },
     "readable.pipe": { argTypes: [null, null, BOOL], result: VOID },
@@ -3287,12 +3484,22 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * the value's inspection) — the frontend routes null/undefined to a
      * no-op and everything else here (Node throws for falsy values too).
      * All arguments are borrowed. */
-    "assert.ok": { argTypes: [BOOL, STRING], result: VOID },
+    "assert.ok": { argTypes: [BOOL, STRING, BOOL], result: VOID },
+    /** The next AssertionError's actual, expected and operator, recorded on
+     * a failure branch. */
+    "assert.record": { argTypes: [DYN, DYN, STRING], result: VOID },
+    "assert.errorNew": { argTypes: [DYN], result: { kind: "object", className: "%AssertionError" } },
     "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 },
+    "assert.looseDeepResult": { argTypes: [BOOL, BOOL, STRING, BOOL], result: VOID },
+    "assert.looseDeepDyn": { argTypes: [DYN, DYN, BOOL, STRING, BOOL], result: VOID },
+    "assert.partialDeepDyn": { argTypes: [DYN, DYN, STRING, BOOL], result: VOID },
+    "assert.partialDeepResult": { argTypes: [BOOL, BOOL, STRING, BOOL], result: VOID },
+    "assert.partialEqDyn": { argTypes: [DYN, DYN], result: BOOL },
+    "assert.looseF64Eq": { argTypes: [F64, F64], result: BOOL },
     "assert.sameValue": { argTypes: [F64, F64], result: BOOL },
     // The deep-equality pair memo: both slots are program-dependent
     // (any cycle-capable record/array/map type).
@@ -3304,11 +3511,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "assert.match": { argTypes: [STRING, REGEX, BOOL, STRING, BOOL], result: VOID },
     "assert.throwsNone": { argTypes: [BOOL, STRING, BOOL, STRING, BOOL], result: VOID },
     "assert.throwsMismatch": {
-        argTypes: [STRING, { kind: "object", className: "%Error" }, STRING, BOOL],
+        argTypes: [STRING, { kind: "object", className: "%Error" }, STRING, BOOL, BOOL],
         result: VOID,
     },
     "assert.throwsRegex": {
-        argTypes: [REGEX, { kind: "object", className: "%Error" }, STRING, BOOL],
+        argTypes: [REGEX, { kind: "object", className: "%Error" }, STRING, BOOL, BOOL],
         result: VOID,
     },
     // Symbol strict equality (pointer identity; scr_symbol.c).
@@ -3326,7 +3533,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "assert.shapeBegin": { argTypes: [{ kind: "object", className: "%Error" }], result: VOID },
     "assert.shapeStr": { argTypes: [F64, STRING], result: VOID },
     "assert.shapeRe": { argTypes: [F64, REGEX], result: VOID },
-    "assert.shapeEnd": { argTypes: [STRING, BOOL], result: VOID },
+    "assert.shapeEnd": { argTypes: [STRING, BOOL, BOOL], result: VOID },
     "assert.regexErrTest": {
         argTypes: [REGEX, { kind: "object", className: "%Error" }],
         result: BOOL,
@@ -3358,6 +3565,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "assert.refEqBytes": { argTypes: [null, null, BOOL, BOOL, STRING, BOOL], result: VOID },
     "assert.refEqFn": { argTypes: [null, null, BOOL, STRING, BOOL], result: VOID },
     "assert.bytesDeepEq": { argTypes: [null, null, BOOL], result: BOOL },
+    "assert.looseBytesEq": { argTypes: [null, null], result: BOOL },
     // util.inspect: the error receiver is program-dependent (a builtin or
     // user error class — the error.toString precedent, null slot).
     "insp.f64": { argTypes: [F64], result: STRING },
@@ -3385,6 +3593,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "insp.seenPush": { argTypes: [null], result: VOID },
     "insp.refWrap": { argTypes: [null, STRING], result: STRING },
     "insp.circular": { argTypes: [F64], result: STRING },
+    /* Whether a closed declared-field record kept the undeclared properties
+     * of its checked source (scr_record_source_note): reflective surfaces
+     * (inspect, Object.keys/values/entries) then answer through its live
+     * checked view. The receiver is any such record type. Never throws. */
+    "record.sourceHas": { argTypes: [null], result: BOOL },
     "insp.key": { argTypes: [STRING], result: STRING },
     "insp.moreItems": { argTypes: [F64], result: STRING },
     "insp.end": { argTypes: [STRING, STRING, STRING, F64, BOOL, BOOL], result: STRING },
@@ -3455,6 +3668,16 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * turns, Node's check phase). Neither throws. */
     "tp.setTimeout": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
     "tp.setImmediate": { argTypes: [], result: { kind: "promise", inner: VOID } },
+    /** events.once (scr_events_emitter.c): [emitter, name, boxer,
+     * errorBoxer, listenForError] → a pending promise of any[]; the boxers
+     * turn the event's and the 'error' tuple into that array. */
+    "events.once": { argTypes: [null, STRING, null, null, BOOL], result: VOID },
+    /** The resolve-value forms: [ms?, value, ref] → a pending promise of the
+     * value's type that copies the borrowed already-resolved `value` promise
+     * when the timer (or immediate) fires; ref false unrefs it. The result
+     * type follows the value promise. */
+    "tp.setTimeoutValue": { argTypes: [F64, null, BOOL], result: VOID },
+    "tp.setImmediateValue": { argTypes: [null, BOOL], result: VOID },
     /** node:diagnostics_channel (scr_dc.c, linked when any dc.* appears —
      * the zlib gating precedent): a process-global name→channel registry;
      * channel values are f64 handles (type-mapper.ts maps Channel to F64, the