@scriptc/compiler 0.3.2 → 0.3.3

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
@@ -1242,8 +1369,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 },
@@ -1274,6 +1402,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 },
@@ -1407,11 +1539,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": {
@@ -1638,7 +1770,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,7 +2245,7 @@ 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 },
@@ -2129,10 +2261,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 },
@@ -2291,6 +2459,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 +2589,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 +2935,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,6 +3106,14 @@ 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 },
@@ -2916,6 +3124,25 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * 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 } },
     /** node:stream/consumers — the promise consumers over the readable
      * machinery: (s) → a pending promise settled at the terminal point
@@ -3051,7 +3278,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.
@@ -3136,7 +3363,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 +3388,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 +3407,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