@scriptc/compiler 0.3.2 → 0.3.4

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, 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, } from "./ir.js";
 /** Preserve the closed names while giving every entry the same slot type. */
 function defineLibFnSignatures(signatures) {
     return signatures;
@@ -26,7 +26,37 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "event.new": { argTypes: [DYN], result: DYN },
     "event.customNew": { argTypes: [DYN], result: DYN },
     "event.is": { argTypes: [DYN, F64], result: BOOL },
+    /** Compiled EventTarget and Event subclasses: the receiver is the
+     * instance (an object rooted at %EventTarget / %Event). targetInit and
+     * init are super() (init takes the argument vector as one dyn array
+     * and throws the constructor's validation errors; initType is the
+     * super(type) form with a string); targetCall runs an EventTarget method
+     * with the instance's own capsule as `self` (targetDispatch is its
+     * dispatchEvent(event) form, answering the bool); call, get and set
+     * reach the Event members. */
+    "event.targetInit": { argTypes: [null], result: VOID },
+    "event.init": { argTypes: [null, DYN], result: VOID },
+    "event.initType": { argTypes: [null, STRING], result: VOID },
+    /** %main hands the engine the compiled `listener.handleEvent` reader
+     * (lower-event-target.ts noteEventListeners). */
+    "event.handleEventReader": { argTypes: [DYN], result: VOID },
+    "event.targetDispatch": { argTypes: [null, DYN, DYN], result: BOOL },
+    "event.targetCall": { argTypes: [null, DYN, STRING, DYN], result: DYN },
+    "event.call": { argTypes: [null, STRING, DYN], result: DYN },
+    "event.get": { argTypes: [null, STRING], result: DYN },
+    "event.set": { argTypes: [null, STRING, DYN], result: VOID },
     "events.addAbortListener": { argTypes: [DYN, DYN], result: DYN },
+    /** Blob / File (scr_blob.c): the constructors and slice() take their
+     * argument vector as one dyn array and throw Node's validation errors;
+     * the readers settle on Node's microtask turn for the Blob's parts.
+     * `blob.is` is `v instanceof Blob` (kind 0) or `File` (1). */
+    "blob.new": { argTypes: [DYN], result: DYN },
+    "blob.fileNew": { argTypes: [DYN], result: DYN },
+    "blob.slice": { argTypes: [DYN, DYN], result: DYN },
+    "blob.text": { argTypes: [DYN], result: { kind: "promise", inner: STRING } },
+    "blob.bytes": { argTypes: [DYN], result: { kind: "promise", inner: BYTES_U8 } },
+    "blob.arrayBuffer": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
+    "blob.is": { argTypes: [DYN, F64], result: BOOL },
     "abort.timeout": { argTypes: [DYN], result: DYN },
     "abort.now": { argTypes: [DYN], result: DYN },
     "abort.any": { argTypes: [DYN], result: DYN },
@@ -62,8 +92,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * "Cannot set properties of undefined (setting 'k')"; every other kind
      * throws Node's STRICT-mode "Cannot create property 'k' on <kind>" —
      * primitives quoting their rendering, V8's "on number '5'"
-     * (sloppy mode would silently ignore — suite tests are 'use strict';
-     * SEMANTICS.md notes the sloppy divergence: loud, never silent). Void
+     * (sloppy mode would ignore the write — suite tests are 'use strict';
+     * SEMANTICS.md notes the sloppy divergence: the write throws). Void
      * result; in the may-throw seed set. */
     "dyn.keySet": { argTypes: [DYN, STRING, DYN], result: VOID },
     "dyn.keySetComputed": { argTypes: [DYN, DYN, DYN], result: VOID },
@@ -81,6 +111,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.globalSymbolDelete": { argTypes: [SYMBOL_T], result: VOID },
     /** Exact native class capsule identity, without materializing its fields. */
     "dyn.typedRefIs": { argTypes: [DYN, STRING], result: BOOL },
+    /** A capsule boxed by this program from exactly this class: one key
+     * pointer test, false for equal keys boxed elsewhere. Guards fast paths
+     * whose fallback handles every other value. The key is a literal. */
+    "dyn.typedRefKeyIs": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.classIs": { argTypes: [DYN, STRING], result: BOOL },
     /** Destructuring pack over a dyn source — `const [a, b] = d`, a
      * destructured dyn callback param (args: the source and the STATIC
@@ -135,7 +169,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * Value descriptors become own properties on OBJ and FUNC targets;
      * OBJ targets preserve data attributes. get/set
      * descriptors and non-object targets/descriptors throw catchably
-     * (Node's TypeError texts; accessors the loud unsupported Error). In
+     * (Node's TypeError texts; accessors the "not supported yet" Error). In
      * the may-throw seed set. */
     "dyn.defineProps": { argTypes: [DYN, DYN], result: DYN },
     "dyn.defineProperty": { argTypes: [DYN, DYN, DYN], result: DYN },
@@ -251,6 +285,34 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "process.uptime": { argTypes: [], result: F64 },
     /** perf_hooks performance.now(): fractional ms since process start. */
     "perf.now": { argTypes: [], result: F64 },
+    /** perf_hooks user timing over the thread's performance timeline. The
+     * producing calls take the call's whole argument vector as one dyn
+     * array (Node's validation and errors run in the runtime, MAY THROW):
+     * mark/measure answer 1, entries(args, which) the entry count of
+     * getEntries (0), getEntriesByName (1) or getEntriesByType (2). The
+     * entryName/Type/Start/Duration/Detail accessors read entry i of that
+     * answer; the frontend builds a new entry's record from them and hands
+     * it to entryKeep (a typed reference capsule), and the getters read the
+     * kept records back through entryRef, so entries keep their identity. */
+    "perf.mark": { argTypes: [DYN], result: F64 },
+    "perf.measure": { argTypes: [DYN], result: F64 },
+    "perf.entries": { argTypes: [DYN, F64], result: F64 },
+    "perf.clearMarks": { argTypes: [DYN], result: VOID },
+    "perf.clearMeasures": { argTypes: [DYN], result: VOID },
+    "perf.entryName": { argTypes: [F64], result: STRING },
+    "perf.entryType": { argTypes: [F64], result: STRING },
+    "perf.entryStart": { argTypes: [F64], result: F64 },
+    "perf.entryDuration": { argTypes: [F64], result: F64 },
+    "perf.entryDetail": { argTypes: [F64], result: DYN },
+    "perf.entryKeep": { argTypes: [DYN], result: VOID },
+    "perf.entryRef": { argTypes: [F64], result: DYN },
+    /** process.memoryUsage(): memoryUsageTake samples the resident set and
+     * the runtime heap once (MAY THROW Node's uv_resident_set_memory error)
+     * and memoryUsageField(k) reads that sample (0 rss, 1 heapTotal, 2
+     * heapUsed, 3 external, 4 arrayBuffers). rss is memoryUsage.rss(). */
+    "process.memoryUsageTake": { argTypes: [], result: VOID },
+    "process.memoryUsageField": { argTypes: [F64], result: F64 },
+    "process.rss": { argTypes: [], result: F64 },
     "process.availableMemory": { argTypes: [], result: F64 },
     "process.constrainedMemory": { argTypes: [], result: F64 },
     "process.cpuUser": { argTypes: [], result: F64 },
@@ -268,8 +330,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "timers.immediateRef": { argTypes: [F64], result: F64 },
     "timers.immediateHasRef": { argTypes: [F64], result: BOOL },
     /** The tolerated non-handle clear (`clearTimeout(null)`,
-     * `clearInterval({})`, zero-argument forms): Node silently ignores
-     * anything that is not a live handle — a VOID no-op the emitter drops
+     * `clearInterval({})`, zero-argument forms): Node ignores anything
+     * that is not a live handle without an error — a VOID no-op the emitter drops
      * (only syntactically side-effect-free arguments take this path). */
     "timers.clearNoop": { argTypes: [], result: VOID },
     // Signal listeners are zero-param (the ambient shape); exit/stdin
@@ -314,7 +376,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fs.readFileSyncBuf": { argTypes: [STRING], result: BYTES_U8 },
     /** readFileSync(path, enc) with a RUNTIME encoding (an untyped JS
      * parameter): undefined/null answer Buffers, utf8 a string, other real
-     * encodings fence loudly, unknown names throw ERR_UNKNOWN_ENCODING. */
+     * encodings throw the "not supported yet" Error, unknown names throw
+     * ERR_UNKNOWN_ENCODING. */
     "fs.readFileSyncDyn": { argTypes: [STRING, DYN], result: DYN },
     "fs.writeFileSync": { argTypes: [STRING, STRING], result: VOID },
     "fs.appendFileSync": { argTypes: [STRING, STRING], result: VOID },
@@ -330,12 +393,40 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * to lstat, Node's getDirents rule). The result type is the call site's
      * interned Dirent record array (name, parentPath, hidden %dtype in
      * libuv's UV_DIRENT encoding) — verified by the frontend; the emitter
-     * assembles the rows from the snapshot. OS order, no "."/"..". Throws
+     * assembles the rows from the snapshot. Byte order on POSIX (libuv
+     * sorts), the directory's order on Windows; no "."/"..". Throws
      * Node's scandir errno error (may-throw seed set); fresh +1 array. */
     "fs.readdirTypesSync": { argTypes: [STRING], result: VOID },
+    /** fs.globSync / fs.glob / fs/promises glob (scr_glob.c, Node's
+     * lib/internal/fs/glob.js walk): pattern and options are dyn values the
+     * runtime validates in Node's order. The string forms answer string[];
+     * the Dirent forms answer the call site's Dirent record array (validated
+     * in validate.ts) assembled from the snapshot; fs.callbackGlob takes the
+     * argument vector and calls back with string[]. */
+    "fs.globSync": { argTypes: [DYN, DYN], result: arrayOf(STRING) },
+    "fs.globTypesSync": { argTypes: [DYN, DYN], result: VOID },
+    "fs.callbackGlob": { argTypes: [DYN], result: VOID },
+    "fsp.globStrings": { argTypes: [DYN, DYN], result: arrayOf(STRING) },
+    "fsp.globTypes": { argTypes: [DYN, DYN], result: VOID },
+    /** The error an fs/promises glob walk ended with (undefined when none),
+     * read once right after fsp.globStrings / fsp.globTypes. */
+    "fsp.globError": { argTypes: [], result: DYN },
+    /** fs.Dir (scr_lib.c): opendirSync(path, bufferSize) throws Node's
+     * opendir error (or the options.bufferSize RangeError); dir.readSync
+     * answers the call site's `Dirent | null` (VOID here — the emitter builds
+     * the row like readdirTypesSync) and dir.read is its promise twin;
+     * readSync and closeSync throw ERR_DIR_CLOSED on a closed Dir, read and
+     * close reject with it. */
+    "fs.opendirSync": { argTypes: [STRING, F64], result: DIR_T },
+    "fsp.opendir": { argTypes: [STRING, F64], result: { kind: "promise", inner: DIR_T } },
+    "dir.path": { argTypes: [DIR_T], result: STRING },
+    "dir.readSync": { argTypes: [DIR_T], result: VOID },
+    "dir.read": { argTypes: [DIR_T], result: { kind: "promise", inner: VOID } },
+    "dir.closeSync": { argTypes: [DIR_T], result: VOID },
+    "dir.close": { argTypes: [DIR_T], result: { kind: "promise", inner: VOID } },
     /** node:path (scr_path.c ports BOTH of Node's implementations
      * function-by-function): the `path.*` family is posix, the
-     * `path.win32*` family is Node v24's path.win32 byte-for-byte — the
+     * `path.win32*` family is Node v24's path.win32 ported exactly — the
      * frontend binds the bare module to the TARGET platform's family
      * (Node on Windows IS path.win32) and the path.posix / path.win32
      * namespaces to their own family everywhere. join and resolve take ONE
@@ -699,6 +790,18 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "url.fileURLToPathUrl": { argTypes: [URL_T], result: STRING },
     "url.fileURLToPathChecked": { argTypes: [DYN], result: STRING },
     "url.fileURLToPathOptions": { argTypes: [DYN, DYN], result: STRING },
+    /** node:url's legacy API (scr_url_legacy.c): parse(url, parseQueryString,
+     * slashesDenoteHost) answers the checked-dynamic Url instance; format
+     * takes the urlObject (a Url-shaped object, a string, or a URL) and the
+     * URL form's options; resolve takes (from, to). The trailing bool says
+     * whether the call site emits DEP0169. domainToASCII/domainToUnicode
+     * take the domain and whether it was omitted. Node's validation errors
+     * throw catchably. */
+    "url.legacyParse": { argTypes: [DYN, DYN, DYN, BOOL], result: DYN },
+    "url.legacyFormat": { argTypes: [DYN, DYN, BOOL], result: STRING },
+    "url.legacyResolve": { argTypes: [DYN, DYN, BOOL], result: STRING },
+    "url.domainToASCII": { argTypes: [DYN, BOOL], result: STRING },
+    "url.domainToUnicode": { argTypes: [DYN, BOOL], result: STRING },
     "url.fileURLToPathBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
     "url.pathToFileURLChecked": { argTypes: [DYN, DYN], result: URL_T },
     "url.fileURLToPathStr": { argTypes: [STRING], result: STRING },
@@ -883,6 +986,21 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stats.atimeMs": { argTypes: [STATS_T], result: F64 },
     "stats.mtimeMs": { argTypes: [STATS_T], result: F64 },
     "stats.ctimeMs": { argTypes: [STATS_T], result: F64 },
+    "stats.birthtimeMs": { argTypes: [STATS_T], result: F64 },
+    "stats.mode": { argTypes: [STATS_T], result: F64 },
+    "stats.uid": { argTypes: [STATS_T], result: F64 },
+    "stats.gid": { argTypes: [STATS_T], result: F64 },
+    "stats.rdev": { argTypes: [STATS_T], result: F64 },
+    "stats.blksize": { argTypes: [STATS_T], result: F64 },
+    "stats.isBlockDevice": { argTypes: [STATS_T], result: BOOL },
+    "stats.isCharacterDevice": { argTypes: [STATS_T], result: BOOL },
+    "stats.isFIFO": { argTypes: [STATS_T], result: BOOL },
+    "stats.isSocket": { argTypes: [STATS_T], result: BOOL },
+    /** The Date fields: the *Ms value rounded (Node's dateFromMs). */
+    "stats.atime": { argTypes: [STATS_T], result: DATE_T },
+    "stats.mtime": { argTypes: [STATS_T], result: DATE_T },
+    "stats.ctime": { argTypes: [STATS_T], result: DATE_T },
+    "stats.birthtime": { argTypes: [STATS_T], result: DATE_T },
     // The wider sync fs slice (unlink/chmod/chown/copyfile and the
     // mode-carrying write/mkdir forms).
     /** The wider sync fs slice (scr_lib.c), all throwing catchably with
@@ -905,6 +1023,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fs.unlinkSync": { argTypes: [STRING], result: VOID },
     "fs.chmodSync": { argTypes: [STRING, F64], result: VOID },
     "fs.chownSync": { argTypes: [STRING, F64, F64], result: VOID },
+    "fs.lchownSync": { argTypes: [STRING, F64, F64], result: VOID },
+    "fs.fchownSync": { argTypes: [F64, F64, F64], result: VOID },
+    /** truncateSync opens the path with 'r+', then truncates (len checked and
+     * clamped like ftruncateSync's) and closes it. */
+    "fs.truncateSync": { argTypes: [STRING, F64], result: VOID },
     "fs.copyFileSync": { argTypes: [STRING, STRING], result: VOID },
     /** renameSync is the direct two-path syscall wrapper. renameCb defers
      * the operation to the loop and fires a program-shaped Error | null
@@ -1013,6 +1136,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "net.serverPort": { argTypes: [NETSERVER_T], result: F64 },
     "net.serverListening": { argTypes: [NETSERVER_T], result: BOOL },
+    /** socket.ref()/unref() and server.ref()/unref(): whether the handle
+     * keeps the event loop alive. */
+    "net.sockSetRef": { argTypes: [NETSOCKET_T, BOOL], result: VOID },
+    "net.serverSetRef": { argTypes: [NETSERVER_T, BOOL], result: VOID },
     // net.serverAddress's record result is shape-checked in the libCall case
     // (the dgram.address sentinel pattern).
     /** server.address() as the full AddressInfo record (the dgram.address
@@ -1165,6 +1292,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
@@ -1184,7 +1318,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 },
@@ -1197,6 +1331,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
@@ -1242,8 +1383,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** The ServerResponse member surface: statusCode/statusMessage reads
      * and assignments (Node's writable properties), the header CRUD trio
      * (getHeader answers `string | undefined` like reqHeader), and
-     * end(cb)'s finish slot (resOnFinish registers, the end call follows —
-     * the callback fires deferred, Node's 'finish' emit). writeHead's
+     * end(cb)'s callback slot (resOnEndCallback registers, the end call
+     * follows — the callback fires deferred, just before Node's 'finish'
+     * emit; resOnFinish is the 'finish' listener slot). writeHead's
      * statusMessage forms compose in interned helpers: resStatusMsgSet
      * then the ordinary writeHead entry. */
     "http.resStatusGet": { argTypes: [HTTPRES_T], result: F64 },
@@ -1265,6 +1407,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 },
@@ -1274,6 +1419,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }],
         result: VOID,
     },
+    "http.resOnEndCallback": {
+        argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }],
+        result: VOID,
+    },
     "http.reqUrl": { argTypes: [HTTPREQ_T], result: STRING },
     "http.reqMethod": { argTypes: [HTTPREQ_T], result: STRING },
     "http.reqHeader": { argTypes: [HTTPREQ_T, STRING], result: VOID },
@@ -1286,6 +1435,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)],
@@ -1344,6 +1497,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 },
@@ -1407,11 +1563,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "http.resWriteHeadPairs": { argTypes: [HTTPRES_T, F64, arrayOf(STRING)], result: VOID },
     /** writeHead(status, headers) with a checked-dynamic headers value —
-     * the runtime OBJ walk (string/number values; loud fences otherwise;
-     * may throw). */
+     * the runtime OBJ walk (string/number values; other values throw
+     * Node's invalid-argument TypeError; may throw). */
     "http.resWriteHeadDyn": { argTypes: [HTTPRES_T, F64, DYN], result: VOID },
     "net.sockSetTimeout": { argTypes: [NETSOCKET_T, F64], result: VOID },
-    /** setEncoding('utf8') — 'data' delivers strings inside the chunk-encoding window; other real encodings fence loudly, unknown names throw ERR_UNKNOWN_ENCODING (may throw). */
+    /** setEncoding('utf8') — 'data' delivers strings inside the chunk-encoding window; other real encodings throw the "not supported yet" Error, unknown names throw ERR_UNKNOWN_ENCODING (may throw). */
     "net.sockSetEncoding": { argTypes: [NETSOCKET_T, STRING], result: VOID },
     "http.reqSetEncoding": { argTypes: [HTTPREQ_T, STRING], result: VOID },
     "net.sockOnTimeout": {
@@ -1505,6 +1661,38 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "net.sockSetNoDelay": { argTypes: [NETSOCKET_T, BOOL], result: NETSOCKET_T },
     "net.sockDestroySoon": { argTypes: [NETSOCKET_T], result: VOID },
     "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.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). */
@@ -1638,7 +1826,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * for the server_name extension BEFORE the TLS handshake begins, calls
      * the callback with (servername, answer-closure), and resumes the
      * handshake when the answer arrives — cb(err) tears the socket down
-     * silently (Node's 'tlsClientError' default), cb(null, ctx) serves
+     * without an error event (Node's 'tlsClientError' default), cb(null, ctx) serves
      * ctx's cert/key, cb(null, undefined) serves the default pair. */
     "http2.createSecureServerSni": { argTypes: [null, null, null, BOOL], result: NETSERVER_T },
     // The ALPN=h2 server (createSecureServer without allowHTTP1): the real
@@ -2113,11 +2301,15 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "crypto.hashDigestStr": { argTypes: [STRING, STRING, STRING], result: STRING },
     "crypto.hashDigestBytes": { argTypes: [STRING, BYTES_U8, STRING], result: STRING },
     /** First-class static Hash/Hmac handles. Constructors validate the
-     * runtime algorithm string (MD5, SHA-1, or SHA-2); update returns the same
+     * runtime algorithm string (every digest Node 24 lists); update returns the same
      * handle by retained identity, copy snapshots Hash state, and digest
      * 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 },
@@ -2129,10 +2321,46 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 },
+    /** The option and any-value forms, with Node's checks at run time. The
+     * Dyn digests return a string or a Buffer, and crypto.hash's Dyn form
+     * either one by its outputEncoding. */
+    "crypto.hashNewOpts": { argTypes: [STRING, DYN], result: CRYPTOHASH_T },
+    "crypto.hmacNewDyn": { argTypes: [STRING, DYN, DYN], result: CRYPTOHMAC_T },
+    "crypto.hashCopyOpts": { argTypes: [CRYPTOHASH_T, DYN], result: CRYPTOHASH_T },
+    "crypto.hashUpdateEnc": { argTypes: [CRYPTOHASH_T, STRING, STRING], result: CRYPTOHASH_T },
+    "crypto.hmacUpdateEnc": { argTypes: [CRYPTOHMAC_T, STRING, STRING], result: CRYPTOHMAC_T },
+    "crypto.hashUpdateDyn": { argTypes: [CRYPTOHASH_T, DYN, DYN], result: CRYPTOHASH_T },
+    "crypto.hmacUpdateDyn": { argTypes: [CRYPTOHMAC_T, DYN, DYN], result: CRYPTOHMAC_T },
+    "crypto.hashDigestDyn": { argTypes: [CRYPTOHASH_T, DYN], result: DYN },
+    "crypto.hmacDigestDyn": { argTypes: [CRYPTOHMAC_T, DYN], result: DYN },
+    "crypto.hashOneshot": { argTypes: [STRING, DYN, DYN], result: DYN },
+    /** Views of any element kind (the validator checks both are views). */
+    "crypto.timingSafeEqual": { argTypes: [null, null], result: BOOL },
+    "crypto.timingSafeEqualDyn": { argTypes: [DYN, DYN], 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.randomIntMax": { argTypes: [F64], result: F64 },
+    /** randomFillSync over any view returns that view at its own type (the
+     * validator checks the result against the first argument). The Dyn form
+     * takes ArrayBuffers and other values. The callback forms carry
+     * randomFill's argument count before the callback; randomIntCb carries
+     * whether min was given. */
+    "crypto.randomFillView": { argTypes: [null, F64, F64], result: BYTES_U8 },
+    "crypto.randomFillViewRest": { argTypes: [null, F64], result: BYTES_U8 },
+    "crypto.randomFillSyncDyn": { argTypes: [DYN, DYN, DYN], result: DYN },
+    "crypto.randomFillCb": { argTypes: [null, F64, F64, F64, null], result: VOID },
+    "crypto.randomFillCbDyn": { argTypes: [DYN, DYN, DYN, F64, null], result: VOID },
+    "crypto.randomIntCb": { argTypes: [F64, F64, F64, null], result: VOID },
+    "crypto.randomUUIDOpts": { argTypes: [DYN], result: STRING },
+    /** Secret KeyObjects: native handles whose getters and methods dispatch
+     * through the handle. keyObjectInput reads a key's bytes for hkdf. */
+    "crypto.createSecretKey": { argTypes: [DYN, DYN], result: DYN },
+    "crypto.generateKeySync": { argTypes: [DYN, DYN], result: DYN },
+    "crypto.generateKeyCb": { argTypes: [DYN, DYN, null], result: VOID },
+    "crypto.keyObjectInput": { argTypes: [DYN], result: BYTES_U8 },
+    "crypto.isKeyObject": { argTypes: [DYN], result: BOOL },
+    "crypto.randomUUIDv7": { argTypes: [DYN], result: STRING },
     "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 },
@@ -2263,6 +2491,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
@@ -2291,6 +2534,17 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fsp.mkdirRecursiveMode": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
     "fsp.unlink": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
     "fsp.chmod": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
+    "fsp.chown": { argTypes: [STRING, F64, F64], result: { kind: "promise", inner: VOID } },
+    "fsp.lchown": { argTypes: [STRING, F64, F64], result: { kind: "promise", inner: VOID } },
+    "fsp.access": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
+    "fsp.truncate": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
+    "fsp.appendFile": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
+    "fsp.appendFileBytes": { argTypes: [STRING, BYTES_U8], result: { kind: "promise", inner: VOID } },
+    "fsp.copyFile": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
+    "fsp.mkdtemp": { argTypes: [STRING], result: { kind: "promise", inner: STRING } },
+    /** readFile(path, encoding | { encoding }) for any runtime encoding name. */
+    "fsp.readFileEncoded": { argTypes: [STRING, STRING], result: { kind: "promise", inner: STRING } },
+    "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.readlink": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
@@ -2410,6 +2664,24 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.generatorThis": { argTypes: [], result: DYN },
     "process.getuid": { argTypes: [], result: F64 },
     "process.getgid": { argTypes: [], result: F64 },
+    /** geteuid(2) / getegid(2) / getgroups(2) (the effective gid appended
+     * when the list lacks it, like Node). Windows has no such members: the
+     * calls throw the TypeError a missing member does (MAY THROW). */
+    "process.geteuid": { argTypes: [], result: F64 },
+    "process.getegid": { argTypes: [], result: F64 },
+    "process.getgroups": { argTypes: [], result: arrayOf(F64) },
+    /** process.ppid: the parent's pid at the read. Never throws. */
+    "process.ppid": { argTypes: [], result: F64 },
+    /** process.title: libuv's process title (argv[0] until set); setTitle
+     * writes it (truncated to the original argument area on POSIX, the
+     * console title on Windows). Never throw. */
+    "process.title": { argTypes: [], result: STRING },
+    "process.setTitle": { argTypes: [STRING], result: VOID },
+    /** process.argv0: the original argv[0]. Never throws. */
+    "process.argv0": { argTypes: [], result: STRING },
+    /** process.release: the compatibility target's stable release object
+     * (name, lts, sourceUrl, headersUrl, and libUrl on Windows). +1. */
+    "process.release": { argTypes: [], result: DYN },
     /** process.execPath: the compiled binary's own resolved absolute path
      * (one interned string, +1 per read) — the honest answer where Node's
      * is the node executable's (SEMANTICS.md divergence 12). Never throws. */
@@ -2738,6 +3010,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.seal": { argTypes: [DYN], result: DYN },
     "dyn.isSealed": { argTypes: [DYN], result: BOOL },
     "dyn.objValues": { argTypes: [DYN], result: DYN },
+    /** Object.values as a native vector of checked values, for results the
+     * program consumes directly (for-of, index reads, read-only methods). */
+    "dyn.objValueList": { argTypes: [DYN], result: arrayOf(DYN) },
     "dyn.objEntries": { argTypes: [DYN], result: DYN },
     /** structuredClone over the checked-dynamic tree (scr_json.c): the JSON-safe subset plus
      * bytes (a fresh copy — a Buffer clones as a plain Uint8Array, like
@@ -2906,17 +3181,62 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * propagates the first error by destroying the rest, calls cb after the
      * last 'close'; answers the destination +1. The Dyn twins take the
      * callback as a checked-dynamic VALUE (mustCall wrappers). */
+    /** stream.addAbortSignal: [stream, signal] — the constructors' signal
+     * option, chained over the fresh stream (falsy signals are ignored);
+     * stream.addAbortSignalFn: [signal, stream] — addAbortSignal(signal,
+     * stream). Both answer the stream (+1) and throw ERR_INVALID_ARG_TYPE
+     * for a value that is not an AbortSignal; they link the event-target
+     * unit (addAbortListener). */
+    "stream.addAbortSignal": { argTypes: [null, DYN], result: VOID },
+    "stream.addAbortSignalFn": { argTypes: [DYN, null], result: VOID },
     "stream.finished": { argTypes: [null, null], result: VOID },
     "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
      * chaining/destroyer semantics settling a void promise (fulfilled on a
      * clean finish, rejected with the finish status otherwise). */
     "sp.finished": { argTypes: [null], result: { kind: "promise", inner: VOID } },
+    /** The options forms: finished(s, { readable, writable, error, cleanup,
+     * signal }) as [s, readable, writable, error, cleanup, signal?] —
+     * readable/writable -1 (absent), 0 or 1 — and pipeline(...streams,
+     * { signal, end }) as [count, s1..sn, end, signal?]. The Signal forms
+     * link the event-target unit (addAbortListener). The callback form
+     * stream.finishedOpts: [s, readable, writable, error, signal?, cb] →
+     * the cleanup closure. */
+    "sp.finishedOpts": {
+        argTypes: [null, F64, F64, BOOL, BOOL],
+        result: { kind: "promise", inner: VOID },
+    },
+    "sp.finishedOptsSignal": {
+        argTypes: [null, F64, F64, BOOL, BOOL, DYN],
+        result: { kind: "promise", inner: VOID },
+    },
+    "sp.pipelineOpts": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
+    "sp.pipelineOptsSignal": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
+    "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
@@ -2973,11 +3293,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 },
@@ -3051,7 +3400,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * the rendering enumerable) or the custom message.
      * assert.throwsRegex: (regex, error, msg, hasMsg) — the
      * assert.throws(fn, /re/) check over String(error), Node's
-     * regex-mismatch message. assert.regexErrTest: doesNotReject's silent
+     * regex-mismatch message. assert.regexErrTest: doesNotReject's
      * regex predicate over String(error) (never throws).
      * assert.unwantedRejection: (error, msg, hasMsg) — doesNotReject's
      * "Got unwanted rejection" throw.
@@ -3060,12 +3409,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).
@@ -3077,11 +3436,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).
@@ -3099,7 +3458,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,
@@ -3131,12 +3490,14 @@ 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 },
     /** util.format %j over a checked-dynamic argument: the runtime dyn
      * walk (JS-exact stringify; root undefined/function prints
-     * "undefined"; a handle in the tree throws the loud fence). */
+     * "undefined"; a handle in the tree throws the "not supported yet"
+     * Error). */
     "insp.jsonDyn": { argTypes: [DYN], result: STRING },
     "insp.str": { argTypes: [STRING], result: STRING },
     "insp.regex": { argTypes: [REGEX], result: STRING },
@@ -3160,6 +3521,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "insp.key": { argTypes: [STRING], result: STRING },
     "insp.moreItems": { argTypes: [F64], result: STRING },
     "insp.end": { argTypes: [STRING, STRING, STRING, F64, BOOL, BOOL], result: STRING },
+    /** A nested inspect inside a custom rendering (PerformanceEntry's
+     * `${name} ${inspect(toJSON)}`): nestedBegin starts a fresh inspect
+     * context, nestedEnd(prefix, inner) restores the caller's and answers
+     * `prefix inner` re-indented at the caller's level (+1). */
+    "insp.nestedBegin": { argTypes: [], result: VOID },
+    "insp.nestedEnd": { argTypes: [STRING, STRING], result: STRING },
     /** node:string_decoder's utf8 StringDecoder (scr_string.c): the decoder
      * value is a one-field record whose f64 PACKS the pending partial
      * sequence (count + up to 3 raw bytes — Node buffers at most 3 for
@@ -3173,27 +3540,46 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "strdec.next": { argTypes: [STRING, F64, BYTES_U8], result: F64 },
     "strdec.end": { argTypes: [STRING, F64], result: STRING },
     // node:readline: the interface handle is f64; the callbacks' func types
-    // are program-dependent (zero-param or (answer: string) — the emitter
-    // picks the adapter), so those slots are null like child.onExit's.
-    /** node:readline's question/close slice (scr_readline.c, linked under
-     * the events gate — these fns imply moduleUsesProcessEvents). The
-     * interface value is an f64 handle (the Timeout-id precedent).
-     * rl.create: [] → f64 — createInterface({ input: process.stdin,
-     * output: process.stdout }), registering the unit's shared stdin
-     * consumer (an OPEN interface keeps the loop alive until close/EOF,
-     * Node's semantics). rl.question: [handle, query, cb] — writes the
-     * query to stdout (Node writes under pipes too) and delivers the next
-     * line's text through a backend-picked adapter (zero-param or
-     * (answer: string)); THROWS Node's "readline was closed" on a closed
-     * interface (may-throw). rl.close: [handle] — fires 'close' listeners
-     * SYNCHRONOUSLY (Node's inline emit) and detaches the consumer (the
-     * loop stops waiting on fd 0). rl.onClose: [handle, cb] — a zero-arg
-     * listener (moves); stdin EOF closes every open interface with the
-     * buffered partial line DISCARDED, like Node. */
-    "rl.create": { argTypes: [], result: F64 },
+    // are program-dependent (the emitter picks the adapter by parameter
+    // count), so those slots are null like child.onExit's.
+    /** node:readline and node:readline/promises (scr_readline.c, linked
+     * under the events gate — these fns imply moduleUsesProcessEvents; a
+     * stream input or output adds scr_stream.c's bridge). The interface
+     * value is an f64 handle (the Timeout-id precedent); an open interface
+     * on stdin keeps the loop alive until close/EOF.
+     * rl.create: [mode, input?, output?, crlfDelay, prompt?] → f64, mode
+     * bits 1 stream input, 2 stream output, 4 stdout output, 16 prompt
+     * (lowerReadlineCreateCall); rl.createSignal: the same plus the
+     * trailing AbortSignal (mode bit 8), which links the event-target unit
+     * for addAbortListener. rl.question: [handle, query, cb] — the callback
+     * form; THROWS ERR_USE_AFTER_CLOSE on a closed interface (may-throw).
+     * rl.questionAsync(Signal): [handle, query, signal?] → promise<string>,
+     * rejecting instead of throwing. rl.close/pause/resume/prompt:
+     * [handle] (pause/resume/prompt throw ERR_USE_AFTER_CLOSE when
+     * closed); rl.setPrompt/getPrompt; rl.write: [handle, data] (throws
+     * when closed). rl.on: [handle, event, cb, once] — the event number
+     * (0 'line', 1 'close', 2 'pause', 3 'resume', 4 'error') and the
+     * listener (moves). rl.iterOpen/iterNext/iterReturn: the async
+     * iterator — iterNext answers promise<dyn> of the line or undefined. */
+    "rl.create": { argTypes: [F64], result: F64 },
+    "rl.createSignal": { argTypes: [F64], result: F64 },
     "rl.question": { argTypes: [F64, STRING, null], result: VOID },
+    "rl.questionAsync": { argTypes: [F64, STRING], result: { kind: "promise", inner: STRING } },
+    "rl.questionAsyncSignal": {
+        argTypes: [F64, STRING, DYN],
+        result: { kind: "promise", inner: STRING },
+    },
     "rl.close": { argTypes: [F64], result: VOID },
-    "rl.onClose": { argTypes: [F64, null], result: VOID },
+    "rl.pause": { argTypes: [F64], result: VOID },
+    "rl.resume": { argTypes: [F64], result: VOID },
+    "rl.prompt": { argTypes: [F64], result: VOID },
+    "rl.setPrompt": { argTypes: [F64, STRING], result: VOID },
+    "rl.getPrompt": { argTypes: [F64], result: STRING },
+    "rl.write": { argTypes: [F64, STRING], 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 },
     /** 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
@@ -3202,6 +3588,12 @@ 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 } },
+    /** 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