@scriptc/compiler 0.3.1 → 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;
@@ -17,6 +17,46 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fetch.responseNew": { argTypes: [DYN, DYN], result: DYN },
     "fetch.input": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "abort.controllerNew": { argTypes: [], result: DYN },
+    /** EventTarget / Event / CustomEvent construction (scr_event_target.c):
+     * the Event constructors take the argument vector as one dyn array and
+     * throw Node's validation errors; `event.is` is `v instanceof Event`
+     * (kind 0), `CustomEvent` (1), `EventTarget` (2). addAbortListener
+     * answers the disposer (the Disposable's [Symbol.dispose]). */
+    "event.targetNew": { argTypes: [], result: DYN },
+    "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 },
@@ -52,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 },
@@ -71,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
@@ -102,6 +146,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * own-member presence, ARR answers 'length'/a valid index — exactly
      * the literal-key dynHasKey path. Proxy has traps may throw. */
     "dyn.hasKey": { argTypes: [DYN, STRING], result: BOOL },
+    /** The `in` operator with a runtime string key: dyn.hasKey plus the
+     * members inherited from builtin and compiled class prototypes. */
+    "dyn.in": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.freeze": { argTypes: [DYN], result: DYN },
     "dyn.isFrozen": { argTypes: [DYN], result: BOOL },
     "dyn.nativeSetNew": { argTypes: [DYN], result: DYN },
@@ -122,13 +169,20 @@ 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 },
     "dyn.getOwnPropertyDescriptor": { argTypes: [DYN, DYN], result: DYN },
     "dyn.arrayProtoCall": { argTypes: [DYN, STRING, DYN], result: DYN },
-    "dyn.promiseAll": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
+    /** Promise.all / Promise.allSettled / Promise.any over a spread
+     * checked-dynamic array: the values, the settled-record array, or the
+     * first fulfillment (AggregateError once every entry rejects).
+     * Thenable elements adopt; the second argument reads a program class
+     * instance's `then` (the compiled property dispatch). */
+    "dyn.promiseAll": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "dyn.promiseAllSettled": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "dyn.promiseAny": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     /** Bare `typeof v` on a dyn value AS A STRING (arg: the dyn value,
      * borrowed; result: an owned string) — the dyn kind's JS answer:
      * undefined→"undefined", null/object/array/bytes→"object" (JS's oldest
@@ -231,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 },
@@ -248,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
@@ -294,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 },
@@ -310,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
@@ -342,6 +453,21 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "path.win32IsAbsolute": { argTypes: [STRING], result: BOOL },
     "path.win32Relative": { argTypes: [STRING, STRING], result: STRING },
     "path.win32ToNamespacedPath": { argTypes: [STRING], result: STRING },
+    /** path.parse: [root, dir, base, ext, name] as a fresh string[] (the
+     * frontend builds the ParsedPath record); path.format: the pathObject's
+     * root, dir, base, name and ext with undefined spelled "". */
+    "path.parse": { argTypes: [STRING], result: arrayOf(STRING) },
+    "path.win32Parse": { argTypes: [STRING], result: arrayOf(STRING) },
+    "path.format": { argTypes: [STRING, STRING, STRING, STRING, STRING], result: STRING },
+    "path.win32Format": { argTypes: [STRING, STRING, STRING, STRING, STRING], result: STRING },
+    /** path.matchesGlob(path, pattern): Node's matchGlobPattern over its
+     * bundled minimatch (scr_glob.c). Both families match case-insensitively
+     * on macOS and Windows hosts like Node's; win32 also accepts either
+     * separator. Throws TypeError for a pattern over 64 Ki code units,
+     * RangeError for a brace sequence too long to expand, and SyntaxError
+     * when a segment's regex is invalid under the u flag. */
+    "path.matchesGlob": { argTypes: [STRING, STRING], result: BOOL },
+    "path.win32MatchesGlob": { argTypes: [STRING, STRING], result: BOOL },
     /** node:os: homedir is $HOME else getpwuid(3); tmpdir is Node's env
      * cascade ($TMPDIR/$TMP/$TEMP else /tmp, one trailing slash trimmed).
      * os.platform() lowers to process.platform — one implementation. */
@@ -357,6 +483,29 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "os.totalmem": { argTypes: [], result: F64 },
     /** os.availableParallelism(): CPUs the process may use (libuv's answer), >= 1. Never throws. */
     "os.availableParallelism": { argTypes: [], result: F64 },
+    /** os.hostname/machine/version/endianness, freemem, uptime and loadavg:
+     * libuv's answers (uname's machine and version fields, gethostname,
+     * "LE"/"BE", free memory in bytes, uptime in seconds, the three load
+     * averages). Fresh results; never throw. */
+    "os.hostname": { argTypes: [], result: STRING },
+    "os.machine": { argTypes: [], result: STRING },
+    "os.version": { argTypes: [], result: STRING },
+    "os.endianness": { argTypes: [], result: STRING },
+    "os.freemem": { argTypes: [], result: F64 },
+    "os.uptime": { argTypes: [], result: F64 },
+    "os.loadavg": { argTypes: [], result: arrayOf(F64) },
+    /** os.getPriority(pid): validateInt32 (RangeError ERR_OUT_OF_RANGE),
+     * then the priority; a failure throws Node's SystemError. */
+    "os.getPriority": { argTypes: [F64], result: F64 },
+    /** os.cpus(): cpusTake snapshots every CPU and answers the count;
+     * cpusModel(i) and cpusField(i, k) (k: 0 speed, 1 user, 2 nice, 3 sys,
+     * 4 idle, 5 irq) read the snapshot. Never throw. */
+    "os.cpusTake": { argTypes: [], result: F64 },
+    "os.cpusModel": { argTypes: [F64], result: STRING },
+    "os.cpusField": { argTypes: [F64, F64], result: F64 },
+    /** os.constants: the per-thread null-prototype constants object (dlopen,
+     * errno, signals, priority, UV_UDP_REUSEADDR). Never throws. */
+    "os.constants": { argTypes: [], result: DYN },
     /** umask(2): arg < 0 reads without setting (umask has no read-only form
      * — set 0, restore); otherwise sets and answers the PREVIOUS mask.
      * Never throws. */
@@ -479,6 +628,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * Latin-script text (scr_str_locale_compare). Never throws. */
     "str.localeCompare": { argTypes: [STRING, STRING], result: F64 },
     "str.replaceLiteral": { argTypes: [STRING, STRING, STRING, BOOL], result: STRING },
+    // (subject, characters, NUL-separated replacement texts): the fused
+    // chain of global one-character replacements.
+    "str.replaceChars": { argTypes: [STRING, STRING, STRING], result: STRING },
     /* ToNumber(string) — ECMA-262 7.1.4.1 StringToNumber (scr_string.c):
      * trim the JS StrWhiteSpace set, empty/whitespace-only → +0, then the
      * whole span must be one StrNumericLiteral — signed decimal (Infinity
@@ -494,8 +646,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * str.encodeUriComponent percent-encodes every byte outside the
      * unreserved component set (ALPHA/DIGIT/- _ . ! ~ * ' ( )) as uppercase
      * %XX — the spec's per-code-point UTF-8 encoding IS a byte scan here —
-     * and never throws (the spec's URIError case is an unpaired surrogate,
-     * which cannot exist in well-formed UTF-8). str.decodeUriComponent
+     * and THROWS the spec's URIError ("URI malformed") on a lone surrogate.
+     * str.decodeUriComponent
      * decodes %XX escapes bytewise (raw non-escape bytes copy through) and
      * requires the escaped bytes to form strictly valid UTF-8 (overlong
      * forms, surrogate code points, and >U+10FFFF refused, per UTF8-decode
@@ -523,7 +675,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "str.decodeUriComponent": { argTypes: [STRING], result: STRING },
     "str.decodeUri": { argTypes: [STRING], result: STRING },
     /** encodeURI: the same Encode() keeping the reserved set and '#'
-     * unescaped — total like the component encoder. Borrow; result +1. */
+     * unescaped — throwing like the component encoder. Borrow; result +1. */
     "str.encodeUri": { argTypes: [STRING], result: STRING },
     /** RegExp.escape (ES2025): per-code-point EncodeForRegExpEscape —
      * leading ASCII alphanumeric hex-escapes, syntax characters and '/'
@@ -638,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 },
@@ -700,9 +864,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** node:querystring (scr_qs.c — link-gated by moduleUsesQs; NOT
      * URLSearchParams: the legacy codec's escaping and '+' rules differ).
      * qs.escape is Node's qsEscape, which encodes exactly the component
-     * unreserved set — it emits the always-linked
-     * scr_str_encode_uri_component, so escape-only programs never pull the
-     * unit. qs.unescape is Node's qsUnescape: strict decodeURIComponent
+     * unreserved set — it emits the always-linked scr_qs_escape, so
+     * escape-only programs never pull the unit. qs.unescape is Node's qsUnescape: strict decodeURIComponent
      * first, the lenient legacy unescapeBuffer fallback on failure (never
      * throws). qs.parse takes (str, sep, eq, maxKeys) — the frontend
      * completes omitted/null sep/eq to "&"/"=" and the omitted maxKeys
@@ -717,7 +880,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * through) — Node's encodeStringified rules run in the runtime, so
      * arrays expand to repeated keys and null/undefined/nested objects are
      * empty values. Custom encoder/decoder options fence at compile time.
-     * All borrow; string results +1; none throw. */
+     * All borrow; string results +1; escape and stringify throw URIError
+     * [ERR_INVALID_URI] on a lone surrogate. */
     "qs.parse": { argTypes: [STRING, STRING, STRING, F64], result: VOID },
     "qs.stringify": { argTypes: [DYN, STRING, STRING], result: STRING },
     "qs.escape": { argTypes: [STRING], result: STRING },
@@ -735,6 +899,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "util.toUSVString": { argTypes: [DYN], result: STRING },
     "util.isDeepStrictEqual": { argTypes: [DYN, DYN, DYN], result: BOOL },
     "util.styleText": { argTypes: [DYN, DYN, DYN], result: STRING },
+    /** util.inherits/deprecate/callbackify/debuglog over checked-dynamic
+     * arguments (scr_util_callable.c). The function results are native dyn
+     * wrappers; call sites with a static function type check them back. */
+    "util.inherits": { argTypes: [DYN, DYN], result: VOID },
+    "util.deprecate": { argTypes: [DYN, DYN, DYN, DYN], result: DYN },
+    "util.callbackify": { argTypes: [DYN], result: DYN },
+    "util.debuglog": { argTypes: [DYN, DYN], result: DYN },
     "util.typeIs": { argTypes: [DYN, STRING], result: BOOL },
     "util.typeValue": { argTypes: [DYN, STRING], result: DYN },
     /** fs.statSync → a Stats value (may throw, like the other sync fs
@@ -815,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
@@ -837,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
@@ -945,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
@@ -1174,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 },
@@ -1206,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 },
@@ -1339,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": {
@@ -1570,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
@@ -2045,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 },
@@ -2061,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 },
@@ -2223,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 } },
@@ -2342,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. */
@@ -2455,6 +2720,32 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "console.new": { argTypes: [F64, F64, BOOL], result: DYN },
     "console.bind": { argTypes: [DYN, F64, null], result: VOID },
     "console.write": { argTypes: [DYN, STRING, BOOL], result: VOID },
+    /** The global console's remaining members (scr_console_native.c; the
+     * group indentation itself lives with the writers in scr_console.c).
+     * Arguments are borrowed; string results are owned. noop is the
+     * emitter-dropped tail of a lowering whose effects sit in statements.
+     * label is `${label}` over a defaulted label (undefined -> "default";
+     * a Symbol throws Node's TypeError). count prints "label: n".
+     * countReset answers the warning text for an unknown (or non-string)
+     * label, "" otherwise. time answers the duplicate-label warning text
+     * or ""; timeEnd/timeLog answer Node's formatted elapsed time, or ""
+     * for an unknown label (timeEnd drops the timer). group adds (+1) or
+     * removes (-1) one two-space indentation step. clear writes the
+     * cursor-home and erase-down sequences when stdout is a terminal.
+     * table renders and prints Node's table for a dyn value (undefined
+     * properties = all). dirDyn is console.dir's inspect of a dyn value
+     * (custom inspection off: a Buffer anywhere inside throws the fence). */
+    "console.noop": { argTypes: [], result: VOID },
+    "console.label": { argTypes: [DYN], result: STRING },
+    "console.count": { argTypes: [STRING], result: VOID },
+    "console.countReset": { argTypes: [DYN], result: STRING },
+    "console.time": { argTypes: [STRING], result: STRING },
+    "console.timeEnd": { argTypes: [STRING], result: STRING },
+    "console.timeLog": { argTypes: [STRING], result: STRING },
+    "console.group": { argTypes: [F64], result: VOID },
+    "console.clear": { argTypes: [], result: VOID },
+    "console.table": { argTypes: [DYN, DYN], result: VOID },
+    "console.dirDyn": { argTypes: [DYN, F64], result: STRING },
     /** A native reference to the global object; known names retain value fences. */
     "global.native": { argTypes: [arrayOf(STRING)], result: DYN },
     // `X.name` through a class value: the arg is a program-dependent
@@ -2512,6 +2803,18 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * list throws DataCloneError, nothing static is transferable). Result
      * +1 %DOMException. */
     "error.domClone": { argTypes: [null, DYN], result: VOID },
+    /** `new AggregateError(errors, message?, options?)` (scr_json.c), in
+     * spec order: newAggregate installs the message and cause (both dyn,
+     * borrowed — the message conversion can throw) and returns an owned
+     * %AggregateError; aggregateSetErrors then stores the iterated list
+     * (borrowed receiver, the dyn array borrowed and retained).
+     * aggregateErrors reads the list (+1, the same array every read). */
+    "error.newAggregate": {
+        argTypes: [DYN, DYN],
+        result: { kind: "object", className: "%AggregateError" },
+    },
+    "error.aggregateSetErrors": { argTypes: [null, DYN], result: VOID },
+    "error.aggregateErrors": { argTypes: [null], result: DYN },
     /** `d instanceof TypeError` (and the other BUILTIN error classes) on a
      * checked-dynamic value (scr_json.c): the from_error cache holds the
      * dyn↔error identity edge, so the test resolves the runtime error and
@@ -2569,6 +2872,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * ("Cannot convert undefined or null to object"). */
     "dyn.objKeys": { argTypes: [DYN], result: DYN },
     "dyn.forInKeys": { argTypes: [DYN], result: DYN },
+    "dyn.forInKeyStrings": { argTypes: [DYN], result: arrayOf(STRING) },
+    "dyn.forInStable": { argTypes: [DYN], result: BOOL },
+    "dyn.objKeyStrings": { argTypes: [DYN], result: arrayOf(STRING) },
+    /** Object.entries as a native [string, any][] (VOID: the tuple row's
+     * shape is program-dependent; the validator checks it). */
+    "dyn.objEntryPairs": { argTypes: [DYN], result: VOID },
     "dyn.hasOwn": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.propertyIsEnumerable": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.assign": { argTypes: [DYN, DYN], result: DYN },
@@ -2626,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
@@ -2658,6 +2970,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "regex.resetLastIndex": { argTypes: [REGEX, F64], result: VOID },
     "regex.newChecked": { argTypes: [DYN, DYN], result: REGEX },
     "regex.replaceCallback": { argTypes: [STRING, REGEX, DYN, BOOL], result: STRING },
+    // Reads of capture args[1] of an execSpans/matchGroups result:
+    // `capture === args[2]`, Number(capture) and parseInt(capture,
+    // args[2]). Borrowed; never throw.
+    "regex.groupEquals": { argTypes: [arrayOf(STRING), F64, STRING], result: BOOL },
+    "regex.groupNumber": { argTypes: [arrayOf(STRING), F64], result: F64 },
+    "regex.groupParseInt": { argTypes: [arrayOf(STRING), F64, F64], result: F64 },
     // node:events EventEmitter: receivers are emitter-hierarchy objects and
     // the chaining forms (on/off/removeAll/setMax) return the receiver's
     // own class — program-dependent object types, checked in the libCall
@@ -2718,6 +3036,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "emitter.getMax": { argTypes: [null], result: F64 },
     "emitter.setDefaultMax": { argTypes: [F64], result: VOID },
     "emitter.getDefaultMax": { argTypes: [], result: F64 },
+    /** The events.errorMonitor event key: an immortal string the runtime
+     * registry matches by identity, so no string event name reaches it. */
+    "emitter.errorMonitor": { argTypes: [], result: STRING },
     // node:stream: receivers are stream-hierarchy objects and several
     // results are program-dependent (the receiver's class, unions) — the
     // libCall case owns those checks. The constructors and a few methods
@@ -2785,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 },
@@ -2795,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
@@ -2930,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.
@@ -3015,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 },
@@ -3039,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
@@ -3052,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
@@ -3159,14 +3533,23 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * Node's payload. */
     "process.onRejectionHandled": { argTypes: [DYN, BOOL], result: VOID },
     "process.offRejectionHandled": { argTypes: [DYN], result: VOID },
-    /** process warnings (scr_lib.c): onWarning/offWarning register dyn
-     * listeners; emitWarning applies Node's full argument grammar over the
-     * call's dyn argument vector (ERR_INVALID_ARG_TYPE TypeErrors — MAY
-     * THROW; a listener throw propagates too) and always prints Node's
-     * stderr report. Emission is synchronous (SEMANTICS.md). */
+    /** process warnings (scr_async_dyn.c): onWarning/offWarning register
+     * dyn listeners; emitWarning applies Node's full argument grammar over
+     * the call's dyn argument vector (ERR_INVALID_ARG_TYPE TypeErrors — MAY
+     * THROW) and emits on the next tick, like Node: Node's stderr report,
+     * then the listeners. */
     "process.onWarning": { argTypes: [DYN], result: VOID },
     "process.offWarning": { argTypes: [DYN], result: VOID },
     "process.emitWarning": { argTypes: [DYN], result: VOID },
+    /** A Warning-typed process warning with this message (the console
+     * members' warnings), emitted on the next tick as Node's emitWarning
+     * does (so the loop runs); an empty message emits nothing. */
+    "process.emitWarningText": { argTypes: [STRING], result: VOID },
+    /** process.noDeprecation (0) / process.throwDeprecation (1): the stored
+     * value (undefined until assigned) and its assignment. util.deprecate's
+     * warnings and DeprecationWarning emissions read their truthiness. */
+    "process.deprecationFlag": { argTypes: [F64], result: DYN },
+    "process.setDeprecationFlag": { argTypes: [F64, DYN], result: VOID },
     /** AsyncLocalStorage (node:async_hooks — scr_async.c): stores are f64
      * handles; contexts are immutable fiber-carried snapshots (spawned
      * fibers inherit the spawner's — Node's init-time capture). run/exit
@@ -3262,8 +3645,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * behavioral difference; ignoreBOM defaults to false). Inline calls
      * lower directly; stored decoder records dispatch by encoding id.
      * TextEncoder.encode needs no libFn: its matching forms
-     * lower to buffer.fromStr(s, "utf8") (identical bytes — ScrStr storage
-     * is well-formed UTF-8). Borrowed arg; owned (+1) string; never throws. */
+     * lower to buffer.fromStr(s, "utf8") (identical bytes — both write each
+     * lone surrogate as U+FFFD). Borrowed arg; owned (+1) string; never throws. */
     "text.decode": { argTypes: [BYTES_U8], result: STRING },
     "bytes.bufferSource": { argTypes: [DYN], result: BYTES_U8 },
     "text.decodeBufferSource": { argTypes: [DYN], result: STRING },