@scriptc/compiler 0.3.4 → 0.3.6

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;
@@ -361,6 +361,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stdin.onData": { argTypes: [null, BOOL], result: VOID },
     "stdin.onEnd": { argTypes: [{ kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "stdin.onError": { argTypes: [null, BOOL], result: VOID },
+    /** process.stdin.on/once('keypress', cb) (scr_readline_tty.c): cb is the
+     * listener as a checked-dynamic function, called with (str, key). */
+    "stdin.onKeypress": { argTypes: [DYN, BOOL], result: VOID },
     /** The for-await chunk source over process.stdin: no args, result
      * Promise<Uint8Array> (+1). Fulfills with the next arrived chunk; the
      * EMPTY bytes value is the done sentinel (POSIX reads never deliver
@@ -912,6 +915,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * calls); the stats.* getters are pure reads on it. */
     "fs.statSync": { argTypes: [STRING], result: STATS_T },
     "fs.lstatSync": { argTypes: [STRING], result: STATS_T },
+    // statSync / lstatSync(path, { throwIfNoEntry }): arg 1 is the flag.
+    // Result is the interned `Stats | undefined` union (the runtime answers
+    // +1-or-NULL; the backend builds the arms).
+    "fs.statProbeSync": { argTypes: [STRING, BOOL], result: VOID },
+    "fs.lstatProbeSync": { argTypes: [STRING, BOOL], result: VOID },
     "fs.fstatSync": { argTypes: [F64], result: STATS_T },
     "fs.fchmodSync": { argTypes: [F64, F64], result: VOID },
     "fs.fsyncSync": { argTypes: [F64], result: VOID },
@@ -924,6 +932,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fs.writevSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
     "fs.linkSync": { argTypes: [DYN, DYN], result: VOID },
     "fs.symlinkSync": { argTypes: [DYN, DYN, DYN], result: VOID },
+    /** fs.cpSync / fs/promises cp (scr_fs_cp.c): src, dest and options are
+     * dyn values the runtime validates in Node's order. */
+    "fs.cpSync": { argTypes: [DYN, DYN, DYN], result: VOID },
     "fs.readlinkSync": { argTypes: [DYN, DYN], result: DYN },
     "fs.statfsSync": { argTypes: [DYN, DYN], result: DYN },
     "fs.readlinkSyncStr": { argTypes: [DYN, DYN], result: STRING },
@@ -1047,6 +1058,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "worker.root": { argTypes: [], result: F64 },
     "worker.data": { argTypes: [], result: DYN },
     "worker.parentPort": { argTypes: [], result: DYN },
+    /** new MessageChannel() ({ port1, port2 }) and receiveMessageOnPort(port)
+     * (scr_worker_events.c; the latter may throw). */
+    "worker.channel": { argTypes: [], result: DYN },
+    "worker.receiveMessageOnPort": { argTypes: [DYN], result: DYN },
     /** child_process.spawnSync (scr_child.c): posix_spawn + waitpid + piped
      * utf8 capture — cmd borrowed, args one borrowed string[] (the frontend
      * completes an omitted list to an empty literal), result an owned (+1)
@@ -1277,6 +1292,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": {
@@ -1315,18 +1346,30 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * consumes. ctxSkip/ctxTodo mark the running test; ctxDiagnostic
      * queues an ℹ line; ctxName reads t.name. Every registration keeps
      * the loop-run emitted (usesTimers) so the runner fiber drains. */
-    "test.register": { argTypes: [STRING, F64, STRING, null, F64, STRING], result: VOID },
-    "test.registerEmpty": { argTypes: [STRING, F64, STRING, F64, STRING], result: VOID },
+    // The trailing three are the { plan, timeout, concurrency } options (plan
+    // -1 without one; timeout read under flag 8; concurrency read under flag
+    // 16, -1 for true). An out-of-range timeout or concurrency throws.
+    "test.register": {
+        argTypes: [STRING, F64, STRING, null, F64, STRING, F64, F64, F64],
+        result: VOID,
+    },
+    "test.registerEmpty": {
+        argTypes: [STRING, F64, STRING, F64, STRING, F64, F64, F64],
+        result: VOID,
+    },
     "test.suite": {
-        argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING, F64],
+        argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING, F64, F64],
         result: VOID,
     },
     "test.hook": { argTypes: [F64, null, F64], result: VOID },
     "test.sub": {
-        argTypes: [TESTCTX_T, STRING, F64, STRING, null, F64, STRING],
+        argTypes: [TESTCTX_T, STRING, F64, STRING, null, F64, STRING, F64, F64, F64],
         result: { kind: "promise", inner: VOID },
     },
-    "test.subEmpty": { argTypes: [TESTCTX_T, STRING, F64, STRING, STRING], result: VOID },
+    "test.subEmpty": {
+        argTypes: [TESTCTX_T, STRING, F64, STRING, F64, STRING, F64, F64, F64],
+        result: VOID,
+    },
     "test.ctxSkip": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxTodo": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxDiagnostic": { argTypes: [TESTCTX_T, STRING], result: VOID },
@@ -1338,6 +1381,17 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     // 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 },
+    // The mock trackers: the module's `mock` and t.mock keep each mock's
+    // restore closure (moved) for restoreAll and reset.
+    "test.mockTrack": { argTypes: [{ kind: "func", params: [], ret: VOID }], result: VOID },
+    "test.mockRestoreAll": { argTypes: [], result: VOID },
+    "test.mockReset": { argTypes: [], result: VOID },
+    "test.ctxMockTrack": {
+        argTypes: [TESTCTX_T, { kind: "func", params: [], ret: VOID }],
+        result: VOID,
+    },
+    "test.ctxMockRestoreAll": { argTypes: [TESTCTX_T], result: VOID },
+    "test.ctxMockReset": { 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
@@ -1616,6 +1670,24 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * accounting is real: over-limit requests defer their dial and queue.
      * MAY THROW. */
     "http.agentNew": { argTypes: [BOOL, BOOL, F64, F64, F64, F64, F64], result: DYN },
+    /** http.request's `signal` option over the fresh request: an aborted
+     * signal destroys it with Node's AbortError now, a later abort event
+     * does the same. A falsy value is ignored; a non-signal throws
+     * ERR_INVALID_ARG_TYPE. */
+    "http.clientSignal": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
+    /** https.request's servername option: the TLS name sent and verified.
+     * The "https." prefix keeps the TLS unit linked. */
+    "https.clientServername": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
+    /** The maxHeaderSize option of createServer / http.request: Node's
+     * validateInteger (ERR_OUT_OF_RANGE) then the header size bound.
+     * MAY THROW. */
+    "http.serverMaxHeaderSize": { argTypes: [NETSERVER_T, F64], result: VOID },
+    "http.clientMaxHeaderSize": { argTypes: [HTTPCLIENTREQ_T, F64], result: VOID },
+    /** req.destroy(err): err becomes the request's 'error'. */
+    "http.clientDestroyError": {
+        argTypes: [HTTPCLIENTREQ_T, { kind: "object", className: "%Error" }],
+        result: VOID,
+    },
     /** The agent-threaded request rows: the http.request/https.request
      * shape with a trailing `agent` dyn argument (an Agent handle, false —
      * the one-shot Connection: close dial — or null/undefined for the
@@ -1660,6 +1732,10 @@ 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. */
@@ -1691,6 +1767,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 },
@@ -1768,6 +1846,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],
@@ -1838,6 +1922,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * h2-only split). args are (cert, key) — PEM strings or Buffers. */
     "http2.createSecureServerH2": { argTypes: [null, null, BOOL], result: NETSERVER_T },
     "http.serverOnRequest": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
+    /** server.on('checkContinue' | 'checkExpectation', (req, res)): the
+     * 'request' listener shape; the last argument picks checkExpectation. */
+    "http.serverOnCheck": { argTypes: [NETSERVER_T, null, BOOL, BOOL], result: VOID },
     "http2.serverOnSessionError": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
     /** The guarded absent-session compatibility call remains a no-op. */
     "http2.streamNoop": { argTypes: [], result: VOID },
@@ -2051,6 +2138,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL],
         result: VOID,
     },
+    "http.clientOnContinue": {
+        argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL],
+        result: VOID,
+    },
     /** execFileSync/execSync as ONE entry (args: cmd, argv, shell, input,
      * cwd, hasEnv, envPairs, timeoutMs, stdoutMode, stderrMode — see
      * scr_runtime.h). Throws Node's exact errors: "Command failed: <cmd>"
@@ -2073,17 +2164,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
@@ -2306,6 +2399,15 @@ 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 },
+    /** The Transform a Hash or Hmac reads and writes as a stream (+1,
+     * created on first use and owned by the value; scr_stream.c). The Piped
+     * form, for pipe destinations and pipeline stages, also keeps the value
+     * alive until the stream flushes or is destroyed. */
+    "crypto.hashStream": { argTypes: [null], result: { kind: "object", className: "%Transform" } },
+    "crypto.hashStreamPiped": {
+        argTypes: [null],
+        result: { kind: "object", className: "%Transform" },
+    },
     /** 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. */
@@ -2386,6 +2488,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. */
@@ -2439,6 +2557,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
@@ -2491,6 +2635,20 @@ 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 one-shot forms with an options value: node_zlib_mode, the input,
+     * the options (validated at runtime with Node's ladder). The Cb form
+     * takes the program-shaped (Error | null, Buffer) callback, which moves. */
+    "zlib.syncOpts": { argTypes: [F64, BYTES_U8, DYN], result: BYTES_U8 },
+    "zlib.cbOpts": { argTypes: [F64, BYTES_U8, DYN, null], result: VOID },
+    /** The checked-dynamic input twins (the JS lane's untyped data). */
+    "zlib.syncOptsDyn": { argTypes: [F64, DYN, DYN], result: BYTES_U8 },
+    "zlib.cbOptsDyn": { argTypes: [F64, DYN, DYN, null], result: VOID },
+    /** util.promisify over the callback one-shots: [mode, data, options]
+     * like zlib.cbOpts → a promise the worker-pool run settles with the
+     * Buffer or the callback form's Error. An options or input error rejects
+     * it; never throws. The Dyn twin takes the JS lane's untyped data. */
+    "zlib.promise": { argTypes: [F64, BYTES_U8, DYN], result: { kind: "promise", inner: BYTES_U8 } },
+    "zlib.promiseDyn": { argTypes: [F64, DYN, DYN], result: { kind: "promise", inner: BYTES_U8 } },
     /** 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
@@ -2547,6 +2705,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fsp.rmdir": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
     "fsp.link": { argTypes: [DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fsp.symlink": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
+    "fsp.cp": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fsp.readlink": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "fsp.statfs": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "fsp.readlinkStr": { argTypes: [DYN, DYN], result: { kind: "promise", inner: STRING } },
@@ -2890,6 +3049,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "error.aggregateSetErrors": { argTypes: [null, DYN], result: VOID },
     "error.aggregateErrors": { argTypes: [null], result: DYN },
+    /** `new SuppressedError(error, suppressed, message?)` (scr_json.c): all
+     * three dyn and borrowed; the message conversion can throw. Returns an
+     * owned %SuppressedError. */
+    "error.newSuppressed": {
+        argTypes: [DYN, DYN, DYN],
+        result: { kind: "object", className: "%SuppressedError" },
+    },
     /** `d instanceof TypeError` (and the other BUILTIN error classes) on a
      * checked-dynamic value (scr_json.c): the from_error cache holds the
      * dyn↔error identity edge, so the test resolves the runtime error and
@@ -2979,6 +3145,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.packPushSpreadIter": { argTypes: [DYN, DYN], result: VOID },
     "dyn.reflectApply": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.reflectGet": { argTypes: [DYN, DYN, DYN], result: DYN },
+    /** `using` / `await using` with a dyn value (scr_json.c): usingMethod
+     * runs the declaration's checks and answers what usingDispose calls at
+     * scope exit (undefined for a null or undefined value). The bool selects
+     * `await using`. Both throw Node's TypeErrors or the method's error. */
+    "dyn.usingMethod": { argTypes: [DYN, BOOL], result: DYN },
+    "dyn.usingDispose": { argTypes: [DYN, DYN], result: DYN },
     "dyn.reflectSet": { argTypes: [DYN, DYN, DYN, DYN], result: BOOL },
     "dyn.reflectDefine": { argTypes: [DYN, DYN, DYN], result: BOOL },
     "dyn.abstractEq": { argTypes: [DYN, DYN], result: BOOL },
@@ -3032,6 +3204,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
@@ -3295,11 +3470,16 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * error. The Dyn twin boxes chunks by runtime tag (the JS lane).
      * 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.from over a checked-dynamic source: [source, options].
+     * readable.fromIter is Readable.from over a class iterator, already
+     * opened: [checked-dynamic { next } object, flags, highWaterMark];
+     * readable.fromAsyncIter is the async class iterator's twin. */
     "readable.nextChunk": { argTypes: [null], result: VOID },
     "readable.nextChunkDyn": { argTypes: [null], result: VOID },
     "readable.fromArr": { argTypes: [null, F64, F64], result: VOID },
     "readable.fromDyn": { argTypes: [DYN, DYN], result: VOID },
+    "readable.fromIter": { argTypes: [DYN, F64, F64], result: VOID },
+    "readable.fromAsyncIter": { argTypes: [DYN, F64, F64], 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
@@ -3518,6 +3698,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 },
@@ -3573,13 +3758,69 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "rl.pause": { argTypes: [F64], result: VOID },
     "rl.resume": { argTypes: [F64], result: VOID },
     "rl.prompt": { argTypes: [F64], result: VOID },
+    /** prompt(preserveCursor): [handle, preserveCursor] */
+    "rl.promptWith": { argTypes: [F64, BOOL], result: VOID },
     "rl.setPrompt": { argTypes: [F64, STRING], result: VOID },
     "rl.getPrompt": { argTypes: [F64], result: STRING },
     "rl.write": { argTypes: [F64, STRING], result: VOID },
+    /** write(data, key): [handle, hasData, data, hasKey, hasName, name,
+     * ctrl, meta, shift] */
+    "rl.writeKey": {
+        argTypes: [F64, BOOL, STRING, BOOL, BOOL, STRING, BOOL, BOOL, BOOL],
+        result: VOID,
+    },
     "rl.on": { argTypes: [F64, F64, null, BOOL], result: VOID },
     "rl.iterOpen": { argTypes: [F64], result: VOID },
     "rl.iterNext": { argTypes: [F64], result: { kind: "promise", inner: DYN } },
     "rl.iterReturn": { argTypes: [F64], result: VOID },
+    /** createInterface's history and editing options (scr_rl_check_options:
+     * [flags, tabSize, escapeCodeTimeout, historySize], may throw;
+     * rl.setOptions: [handle, flags, historySize, removeHistoryDuplicates,
+     * tabSize, escapeCodeTimeout]; rl.setHistory: [handle, history]) and
+     * the member reads (rl.history answers the array, rl.numProp the
+     * numeric member by number). */
+    "rl.checkOptions": { argTypes: [F64, F64, F64, F64], result: VOID },
+    "rl.checkCompleter": { argTypes: [DYN], result: VOID },
+    "rl.setOptions": { argTypes: [F64, F64, F64, BOOL, F64, F64], result: VOID },
+    "rl.setHistory": { argTypes: [F64, arrayOf(STRING)], result: VOID },
+    "rl.history": { argTypes: [F64], result: arrayOf(STRING) },
+    "rl.numProp": { argTypes: [F64, F64], result: F64 },
+    /** Terminal mode (scr_readline_tty.c): rl.terminal: [handle, mode (0
+     * the option's value, 2 output.isTTY of process.stdout), terminal,
+     * completer (undefined when absent), readline/promises], emitted with
+     * scr_insp_dyn when there is a completer; the line, terminal and cursor
+     * members. */
+    "rl.terminal": { argTypes: [F64, F64, BOOL, DYN, BOOL], result: VOID },
+    "rl.line": { argTypes: [F64], result: STRING },
+    "rl.isTerminal": { argTypes: [F64], result: BOOL },
+    "rl.cursor": { argTypes: [F64], result: F64 },
+    /** readline.cursorTo / moveCursor / clearLine / clearScreenDown: rl.seq
+     * [kind (0-3), the first and second numbers, whether the second is
+     * given] answers the data to write after the argument checks (may
+     * throw); rl.moves [dx, dy] says whether moveCursor writes. */
+    "rl.seq": { argTypes: [F64, F64, F64, BOOL], result: STRING },
+    "rl.moves": { argTypes: [F64, F64], result: BOOL },
+    /** getCursorPos() (scr_readline_tty.c, linked through the regex unit
+     * like rl.terminal): [handle, 0 rows | 1 cols] */
+    "rl.cursorPos": { argTypes: [F64, F64], result: F64 },
+    /** readline.emitKeypressEvents (scr_readline_tty.c): rl.keypressStdin
+     * [interface (0: none), escapeCodeTimeout (NaN: the interface's or
+     * 500)], rl.keypressStream [stream, interface, timeout]. */
+    "rl.keypressStdin": { argTypes: [F64, F64], result: VOID },
+    "rl.keypressStream": { argTypes: [null, F64, F64], result: VOID },
+    /** readline/promises Readline over an f64 handle: rl.uiOpen [fd (1
+     * stdout, 2 stderr), autoCommit], rl.uiOpenStream [stream, autoCommit]
+     * (isWritable, may throw); the actions take [handle, ...numbers] (the
+     * checks may throw; cursorTo: [handle, x, whether y is given, y]);
+     * rl.uiCommit answers a promise<void>. */
+    "rl.uiOpen": { argTypes: [F64, BOOL], result: F64 },
+    "rl.uiOpenStream": { argTypes: [null, BOOL], result: F64 },
+    "rl.uiCursorTo": { argTypes: [F64, F64, BOOL, F64], result: VOID },
+    "rl.uiMoveCursor": { argTypes: [F64, F64, F64], result: VOID },
+    "rl.uiClearLine": { argTypes: [F64, F64], result: VOID },
+    "rl.uiClearScreenDown": { argTypes: [F64], result: VOID },
+    "rl.uiRollback": { argTypes: [F64], result: VOID },
+    "rl.uiCommit": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
     /** node:timers/promises — the promisified pair (scr_async.c, beside
      * the timer heap they ride): tp.setTimeout: [ms] → a pending void
      * promise a one-shot heap timer fulfills (the loop's timer phase, FIFO
@@ -3588,6 +3829,10 @@ 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