@scriptc/compiler 0.3.5 → 0.4.0

package/dist/ir/builtin-signatures.js

@@ -1,5 +1,5 @@
 import { BIGINT_T } from "./ir.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DIR_T, DGRAMSOCK_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REGEX, SEARCH_PARAMS_T, SECURECTX_T, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, URL_T, VOID, funcOf, } 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, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REGEX, SEARCH_PARAMS_T, SECURECTX_T, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, URL_T, VOID, funcOf, } from "./ir.js";
 /** Preserve the closed names while giving every entry the same slot type. */
 function defineLibFnSignatures(signatures) {
     return signatures;
@@ -15,6 +15,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * are opaque checked-dynamic handles. */
     "fetch.start": { argTypes: [STRING, DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseNew": { argTypes: [DYN, DYN], result: DYN },
+    "fetch.responseJsonStatic": { 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):
@@ -57,6 +58,45 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 },
+    /** WebAssembly (scr_wasm.c): modules translated at build time
+     * (wasm/translate.ts), found at run time by the SHA-256 of their bytes.
+     * compile and instantiate over bytes settle on a later loop turn;
+     * instantiate over a Module settles now, as in Node. `wasm.is` answers
+     * instanceof for Module, Instance, Memory, Table and Global (kinds 0-4)
+     * and CompileError, LinkError and RuntimeError (5-7); `wasm.errorNew`
+     * constructs one of the error classes (kind 5-7, message, options). */
+    "wasm.compile": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
+    "wasm.validate": { argTypes: [DYN], result: BOOL },
+    "wasm.instantiate": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "wasm.moduleNew": { argTypes: [DYN], result: DYN },
+    "wasm.instanceNew": { argTypes: [DYN, DYN], result: DYN },
+    "wasm.is": { argTypes: [DYN, F64], result: BOOL },
+    "wasm.errorNew": { argTypes: [F64, DYN, DYN], result: DYN },
+    /** new WebAssembly.Memory(descriptor), Table(descriptor, value) and
+     * Global(descriptor, value) (an undefined value is the type's default);
+     * `wasm.withoutNew` throws the TypeError for Module, Instance, Memory,
+     * Table or Global (kinds 0-4) called without new, after its arguments
+     * evaluate. */
+    "wasm.memoryNew": { argTypes: [DYN], result: DYN },
+    "wasm.tableNew": { argTypes: [DYN, DYN], result: DYN },
+    "wasm.globalNew": { argTypes: [DYN, DYN], result: DYN },
+    "wasm.withoutNew": { argTypes: [F64, DYN, DYN], result: DYN },
+    /** WebAssembly.Module.imports(module), exports(module) and
+     * customSections(module, name): checked-dynamic arrays of descriptor
+     * objects and ArrayBuffers. */
+    "wasm.moduleImports": { argTypes: [DYN], result: DYN },
+    "wasm.moduleExports": { argTypes: [DYN], result: DYN },
+    "wasm.moduleCustomSections": { argTypes: [DYN, DYN], result: DYN },
+    /** `v.valueOf()` on a WebAssembly-typed receiver: a Global's value,
+     * dyn.valueOf's answer for anything else. */
+    "wasm.valueOf": { argTypes: [DYN], result: DYN },
+    /** WebAssembly.compile (0), instantiate (1) and validate (2) as function
+     * values, and the namespace object holding them. */
+    "wasm.function": { argTypes: [F64], result: DYN },
+    "wasm.namespace": { argTypes: [], result: DYN },
+    /** The global object viewed through a cast to a type with a WebAssembly
+     * member: an object holding the namespace. */
+    "wasm.globalView": { argTypes: [], result: DYN },
     "abort.timeout": { argTypes: [DYN], result: DYN },
     "abort.now": { argTypes: [DYN], result: DYN },
     "abort.any": { argTypes: [DYN], result: DYN },
@@ -126,12 +166,16 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * not iterable (cannot read property Symbol(Symbol.iterator))"). In the
      * may-throw seed set. */
     "dyn.iterPack": { argTypes: [DYN, STRING], result: DYN },
+    "dyn.destructureRest": { argTypes: [DYN, STRING], result: DYN },
     "dyn.arrayFromIterator": { argTypes: [DYN], result: DYN },
     "dyn.iterator": { argTypes: [DYN, STRING], result: DYN },
     "dyn.iteratorResult": { argTypes: [DYN], result: DYN },
     "dyn.iteratorCanStep": { argTypes: [DYN, DYN], result: BOOL },
     "dyn.iteratorStep": { argTypes: [DYN], result: DYN },
     "dyn.iteratorStepDone": { argTypes: [DYN], result: BOOL },
+    "dyn.setGeneratorMembers": { argTypes: [DYN, DYN], result: VOID },
+    "dyn.iteratorHelperMethod": { argTypes: [STRING], result: DYN },
+    "dyn.collectionIteratorIndex": { argTypes: [DYN], result: F64 },
     "dyn.mapSeedEntries": { argTypes: [DYN], result: DYN },
     "dyn.mapSeedEntry": { argTypes: [DYN], result: DYN },
     /** The for-of-over-dyn pack accessors — the emitted index loop drives
@@ -151,12 +195,47 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.in": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.freeze": { argTypes: [DYN], result: DYN },
     "dyn.isFrozen": { argTypes: [DYN], result: BOOL },
+    /** Object.defineProperty on a declared class field (scr_json.c): the
+     * field's current value (borrowed), its FIELD_* attribute word, the
+     * instance's CLASS_* integrity word, the field name and the descriptor.
+     * Validates as Node does (TypeError "Cannot redefine property: f") and
+     * answers a one-property holder of the defined value and attributes (+1),
+     * read back with class.definedBits and class.definedValue. */
+    "class.defineField": { argTypes: [DYN, F64, F64, STRING, DYN], result: DYN },
+    "class.definedBits": { argTypes: [DYN, STRING], result: F64 },
+    "class.definedValue": { argTypes: [DYN, STRING], result: DYN },
+    /** Whether a property descriptor has a `value` member. */
+    "class.descriptorHasValue": { argTypes: [DYN], result: BOOL },
+    /** Throws Node's TypeError for a write to a read-only class field: the
+     * field name and the instance's class name. */
+    "class.throwReadOnly": { argTypes: [STRING, STRING], result: VOID },
+    /** Throws Node's TypeError for a class field initializer on a
+     * non-extensible instance: the field name. */
+    "class.throwNotExtensible": { argTypes: [STRING], result: VOID },
     "dyn.nativeSetNew": { argTypes: [DYN], result: DYN },
     "dyn.nativeSetIs": { argTypes: [DYN], result: BOOL },
     "dyn.nativeMapIs": { argTypes: [DYN], result: BOOL },
     "dyn.nativeUrlIs": { argTypes: [DYN], result: BOOL },
     "dyn.nativeDateIs": { argTypes: [DYN], result: BOOL },
+    /** A builtin constructor (`Object`, `Date`, `RegExp`, `Map`, `Set`,
+     * `Promise`, `WeakMap`, `WeakSet`) read as a JavaScript value: one
+     * interned function per name, the same one dynamic values answer for
+     * `.constructor`. The name is a compiler-chosen literal. */
+    "dyn.globalConstructor": { argTypes: [STRING], result: DYN },
+    /** A builtin global function (setTimeout, setInterval, setImmediate,
+     * the clear functions, queueMicrotask, process.nextTick) read as a
+     * JavaScript value: one interned function per name whose calls run the
+     * timer APIs (it pulls in the event loop). The name is a compiler-chosen
+     * literal. */
+    "dyn.builtinFunction": { argTypes: [STRING], result: DYN },
     "date.nativeNew": { argTypes: [DYN], result: DYN },
+    /** `new Date(year, monthIndex, ...)` in JavaScript: the argument array's
+     * first seven values pass through ToNumber in order (later ones are
+     * evaluated, never converted), then the local-time field constructor. */
+    "date.nativeNewFields": { argTypes: [DYN], result: DYN },
+    /** `new Date(value)` in JavaScript: a string argument parses with V8's
+     * full date parser; every other value constructs as date.nativeNew. */
+    "date.nativeNewValue": { argTypes: [DYN], result: DYN },
     "date.checkedValue": { argTypes: [DYN], result: DATE_T },
     "dyn.nativeRegexIs": { argTypes: [DYN], result: BOOL },
     /** toString() on a checked-dynamic receiver: runtime kind dispatch
@@ -164,6 +243,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * numbers, booleans, arrays, objects answer JS-exactly; undefined and
      * null throw the catchable TypeError). */
     "dyn.toString": { argTypes: [DYN, DYN, STRING], result: STRING },
+    "dyn.valueOf": { argTypes: [DYN, STRING], result: DYN },
     /** Object.defineProperties over dyn values (args: target, descriptors —
      * both borrowed dyn; result: the target, +1 — JS's return value).
      * Value descriptors become own properties on OBJ and FUNC targets;
@@ -183,6 +263,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 } },
+    /** PromiseResolve over one checked-dynamic value: the promise it holds,
+     * a promise that adopts a thenable's settlement, or a promise fulfilled
+     * with the value. The second argument reads `then` as above. */
+    "dyn.promiseResolve": { 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
@@ -306,6 +390,20 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "perf.entryDetail": { argTypes: [F64], result: DYN },
     "perf.entryKeep": { argTypes: [DYN], result: VOID },
     "perf.entryRef": { argTypes: [F64], result: DYN },
+    /** perf_hooks event-loop metrics (scr_perf_loop.c): loopStart is the
+     * loop's start in performance.now() ms (0 before it), idleTime the idle
+     * ms since. eldNew(resolution ms) creates a monitorEventLoopDelay
+     * histogram handle (MAY THROW Node's resolution RangeError); enable/disable answer whether the state changed;
+     * eldPercentile expects Node's validated range; eldStat(which) reads
+     * 0 min, 1 max, 2 mean, 3 stddev, 4 count, 5 exceeds. */
+    "perf.loopStart": { argTypes: [], result: F64 },
+    "perf.idleTime": { argTypes: [], result: F64 },
+    "perf.eldNew": { argTypes: [F64], result: F64 },
+    "perf.eldEnable": { argTypes: [F64], result: BOOL },
+    "perf.eldDisable": { argTypes: [F64], result: BOOL },
+    "perf.eldReset": { argTypes: [F64], result: VOID },
+    "perf.eldPercentile": { argTypes: [F64, F64], result: F64 },
+    "perf.eldStat": { argTypes: [F64, F64], result: F64 },
     /** 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
@@ -361,6 +459,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stdin.onData": { argTypes: [null, BOOL], result: VOID },
     "stdin.onEnd": { argTypes: [{ kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "stdin.onError": { argTypes: [null, BOOL], result: VOID },
+    /** process.stdin.on/once('keypress', cb) (scr_readline_tty.c): cb is the
+     * listener as a checked-dynamic function, called with (str, key). */
+    "stdin.onKeypress": { argTypes: [DYN, BOOL], result: VOID },
     /** The for-await chunk source over process.stdin: no args, result
      * Promise<Uint8Array> (+1). Fulfills with the next arrived chunk; the
      * EMPTY bytes value is the done sentinel (POSIX reads never deliver
@@ -497,6 +598,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** 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.setPriority(pid, priority): validateInt32 for both (priority in
+     * -20..19, RangeError ERR_OUT_OF_RANGE), then the priority; a failure
+     * throws Node's SystemError. */
+    "os.setPriority": { argTypes: [F64, F64], result: VOID },
     /** 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. */
@@ -506,6 +611,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** os.constants: the per-thread null-prototype constants object (dlopen,
      * errno, signals, priority, UV_UDP_REUSEADDR). Never throws. */
     "os.constants": { argTypes: [], result: DYN },
+    /** fs.constants: the target's cached null-prototype constants object. */
+    "fs.constants": { argTypes: [], result: DYN },
+    /** The deprecated node:constants object (scr_os.c): the os groups and
+     * fs.constants merged with the borrowed baked crypto.constants table,
+     * frozen, one per thread. */
+    "constants.object": { argTypes: [DYN], 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. */
@@ -590,6 +701,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "math.sign": { argTypes: [F64], result: F64 },
     "math.exp": { argTypes: [F64], result: F64 },
     "math.expm1": { argTypes: [F64], result: F64 },
+    "math.f16round": { argTypes: [F64], result: F64 },
     "math.fround": { argTypes: [F64], result: F64 },
     "math.sqrt": { argTypes: [F64], result: F64 },
     "math.log": { argTypes: [F64], result: F64 },
@@ -627,6 +739,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** `a.localeCompare(b)`: -1/0/1 in Node's root-locale collation for
      * Latin-script text (scr_str_locale_compare). Never throws. */
     "str.localeCompare": { argTypes: [STRING, STRING], result: F64 },
+    /** Annex B substr(start, length) with start ToNumber'd and length's
+     * presence; never throws. */
+    "str.substr": { argTypes: [STRING, F64, F64, BOOL], result: STRING },
+    /** toLocaleLowerCase/toLocaleUpperCase (scr_regex.c): the locales value
+     * as written, upper=true for toLocaleUpperCase. Throws for null and for
+     * locale forms with no native rules. */
+    "str.localeCase": { argTypes: [STRING, DYN, BOOL], result: STRING },
     "str.replaceLiteral": { argTypes: [STRING, STRING, STRING, BOOL], result: STRING },
     // (subject, characters, NUL-separated replacement texts): the fused
     // chain of global one-character replacements.
@@ -691,7 +810,15 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "num.toExponential": { argTypes: [F64], result: STRING },
     "num.toFixed0": { argTypes: [F64], result: STRING },
     "num.toFixed": { argTypes: [F64, F64], result: STRING },
+    /** toPrecision(precision) with the argument ToNumber'd and its presence
+     * (undefined answers ToString); toExponential with a DEFINED
+     * fractionDigits. Both throw V8's RangeError for out-of-range digits. */
+    "num.toPrecision": { argTypes: [F64, F64, BOOL], result: STRING },
+    "num.toExponentialDigits": { argTypes: [F64, F64], result: STRING },
     "num.toStringRadix": { argTypes: [F64, DYN], result: STRING },
+    /** toString(radix) with a number radix (scr_lib.c): truncates it as
+     * ToIntegerOrInfinity does, THROWS RangeError outside 2..36. */
+    "num.toStringRadixF64": { argTypes: [F64, F64], result: STRING },
     /** Object.is over two numbers — the spec's SameValue on doubles: NaN
      * equals NaN, +0 differs from -0, everything else is `===`. Plain bool
      * result; never throws. (Union-armed operands take unionEq's sameValue
@@ -802,6 +929,19 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "url.legacyResolve": { argTypes: [DYN, DYN, BOOL], result: STRING },
     "url.domainToASCII": { argTypes: [DYN, BOOL], result: STRING },
     "url.domainToUnicode": { argTypes: [DYN, BOOL], result: STRING },
+    /** node:punycode (scr_url.c): punycode.js 2.1.0's string conversions;
+     * decode/toUnicode (and, past 32-bit deltas, encode/toASCII) throw the
+     * module's RangeErrors, ucs2Encode String.fromCodePoint's. warn marks the
+     * module's first load (scr_async_dyn.c) and reports DEP0040 then unless
+     * the second argument is false: at once for a static ES import, on the
+     * next tick for a require() call. */
+    "punycode.decode": { argTypes: [STRING], result: STRING },
+    "punycode.encode": { argTypes: [STRING], result: STRING },
+    "punycode.toASCII": { argTypes: [STRING], result: STRING },
+    "punycode.toUnicode": { argTypes: [STRING], result: STRING },
+    "punycode.ucs2Decode": { argTypes: [STRING], result: arrayOf(F64) },
+    "punycode.ucs2Encode": { argTypes: [arrayOf(F64)], result: STRING },
+    "punycode.warn": { argTypes: [BOOL, BOOL], result: VOID },
     "url.fileURLToPathBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
     "url.pathToFileURLChecked": { argTypes: [DYN, DYN], result: URL_T },
     "url.fileURLToPathStr": { argTypes: [STRING], result: STRING },
@@ -912,6 +1052,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * calls); the stats.* getters are pure reads on it. */
     "fs.statSync": { argTypes: [STRING], result: STATS_T },
     "fs.lstatSync": { argTypes: [STRING], result: STATS_T },
+    // statSync / lstatSync(path, { throwIfNoEntry }): arg 1 is the flag.
+    // Result is the interned `Stats | undefined` union (the runtime answers
+    // +1-or-NULL; the backend builds the arms).
+    "fs.statProbeSync": { argTypes: [STRING, BOOL], result: VOID },
+    "fs.lstatProbeSync": { argTypes: [STRING, BOOL], result: VOID },
     "fs.fstatSync": { argTypes: [F64], result: STATS_T },
     "fs.fchmodSync": { argTypes: [F64, F64], result: VOID },
     "fs.fsyncSync": { argTypes: [F64], result: VOID },
@@ -924,6 +1069,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fs.writevSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
     "fs.linkSync": { argTypes: [DYN, DYN], result: VOID },
     "fs.symlinkSync": { argTypes: [DYN, DYN, DYN], result: VOID },
+    /** fs.cpSync / fs/promises cp (scr_fs_cp.c): src, dest and options are
+     * dyn values the runtime validates in Node's order. */
+    "fs.cpSync": { argTypes: [DYN, DYN, DYN], result: VOID },
     "fs.readlinkSync": { argTypes: [DYN, DYN], result: DYN },
     "fs.statfsSync": { argTypes: [DYN, DYN], result: DYN },
     "fs.readlinkSyncStr": { argTypes: [DYN, DYN], result: STRING },
@@ -1047,6 +1195,33 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "worker.root": { argTypes: [], result: F64 },
     "worker.data": { argTypes: [], result: DYN },
     "worker.parentPort": { argTypes: [], result: DYN },
+    /** worker_threads.resourceLimits: {} in the main thread; a refusal in a
+     * worker (scr_worker_events.c). */
+    "worker.resourceLimits": { argTypes: [], result: DYN },
+    /** worker_threads.threadName: the Worker's name in a worker, "" in the
+     * main thread (scr_worker.c). */
+    "worker.threadName": { argTypes: [], result: DYN },
+    /** new MessageChannel() ({ port1, port2 }) and receiveMessageOnPort(port)
+     * (scr_worker_events.c; the latter may throw). */
+    "worker.channel": { argTypes: [], result: DYN },
+    "worker.receiveMessageOnPort": { argTypes: [DYN], result: DYN },
+    /** setEnvironmentData(key, value) and getEnvironmentData(key)
+     * (scr_worker_events.c; arguments borrowed). */
+    "worker.setEnvironmentData": { argTypes: [DYN, DYN], result: VOID },
+    "worker.getEnvironmentData": { argTypes: [DYN], result: DYN },
+    /** markAsUntransferable(value) and isMarkedAsUntransferable(value)
+     * (scr_worker_events.c; the value borrowed). */
+    "worker.markUntransferable": { argTypes: [DYN], result: VOID },
+    "worker.isMarkedUntransferable": { argTypes: [DYN], result: BOOL },
+    /** markAsUncloneable(value) (scr_json.c; the value borrowed). */
+    "dyn.markUncloneable": { argTypes: [DYN], result: VOID },
+    /** before new Worker() with the stdout or stderr option: links the stream
+     * unit that worker.stdout and worker.stderr read through (scr_stream.c). */
+    "stream.workerStdio": { argTypes: [], result: VOID },
+    /** new BroadcastChannel(...args) (scr_worker_events.c; may throw), after
+     * event.broadcastInstall, which installs its EventTarget side. */
+    "worker.broadcastChannel": { argTypes: [DYN], result: DYN },
+    "event.broadcastInstall": { argTypes: [], result: VOID },
     /** child_process.spawnSync (scr_child.c): posix_spawn + waitpid + piped
      * utf8 capture — cmd borrowed, args one borrowed string[] (the frontend
      * completes an omitted list to an empty literal), result an owned (+1)
@@ -1107,6 +1282,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "net.createServer": { argTypes: [], result: NETSERVER_T },
     "net.createServerCb": { argTypes: [null], result: NETSERVER_T },
     "net.listen": { argTypes: [NETSERVER_T, F64], result: VOID },
+    /** listen(path[, cb]): a Unix-socket server; the socket file is removed
+     * when the server closes. Failures are the async 'error'. */
+    "net.listenPath": { argTypes: [NETSERVER_T, STRING], result: VOID },
+    "net.listenPathCb": {
+        argTypes: [NETSERVER_T, STRING, { kind: "func", params: [], ret: VOID }],
+        result: VOID,
+    },
     "net.listenCb": {
         argTypes: [NETSERVER_T, F64, { kind: "func", params: [], ret: VOID }],
         result: VOID,
@@ -1149,6 +1331,15 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * answers null (the serverPort stance). */
     "net.serverAddress": { argTypes: [NETSERVER_T], result: VOID },
     "net.serverClose": { argTypes: [NETSERVER_T], result: VOID },
+    /** server.close((err) => ...): the callback (a dyn function) gets
+     * undefined once the server closes, or Node's ERR_SERVER_NOT_RUNNING
+     * when it was not listening. */
+    "net.serverCloseDyn": { argTypes: [NETSERVER_T, DYN], result: VOID },
+    /** server.address() in programs that may listen on a Unix socket: the
+     * path a listening server answers ("" for a TCP server), and the check
+     * a record-typed address() makes first (throws for a Unix server). */
+    "net.serverUnixPath": { argTypes: [NETSERVER_T], result: STRING },
+    "net.serverAddressCheck": { argTypes: [NETSERVER_T], result: VOID },
     "net.serverCloseCb": {
         argTypes: [NETSERVER_T, { kind: "func", params: [], ret: VOID }],
         result: VOID,
@@ -1312,6 +1503,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * callback) and lookupService(address, port, callback). */
     "dns.lookupDyn": { argTypes: [DYN, DYN, DYN, BOOL], result: VOID },
     "dns.lookupService": { argTypes: [DYN, DYN, DYN, BOOL], result: VOID },
+    /** node:dns/promises: lookup(hostname, options) and lookupService(address,
+     * port) over the callback forms; the promise fulfills with the dyn
+     * { address, family } (array for all: true) / { hostname, service }.
+     * Argument errors throw synchronously (may-throw), unlike the
+     * util.promisify forms below. */
+    "dns.promisesLookup": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "dns.promisesLookupService": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "dns.getServers": { argTypes: [], result: DYN },
     "dns.getDefaultResultOrder": { argTypes: [], result: STRING },
     "dns.setDefaultResultOrder": { argTypes: [DYN], result: VOID },
@@ -1331,29 +1529,85 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * consumes. ctxSkip/ctxTodo mark the running test; ctxDiagnostic
      * queues an ℹ line; ctxName reads t.name. Every registration keeps
      * the loop-run emitted (usesTimers) so the runner fiber drains. */
-    "test.register": { argTypes: [STRING, F64, STRING, null, F64, STRING], result: VOID },
-    "test.registerEmpty": { argTypes: [STRING, F64, STRING, F64, STRING], result: VOID },
-    "test.suite": {
-        argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING, F64],
+    // The trailing three are the { plan, timeout, concurrency } options (plan
+    // -1 without one; timeout read under flag 8; concurrency read under flag
+    // 16, -1 for true). An out-of-range timeout or concurrency throws.
+    "test.register": {
+        argTypes: [STRING, F64, STRING, null, F64, STRING, F64, F64, F64],
+        result: VOID,
+    },
+    "test.registerEmpty": {
+        argTypes: [STRING, F64, STRING, F64, STRING, F64, F64, F64],
         result: VOID,
     },
-    "test.hook": { argTypes: [F64, null, F64], result: VOID },
+    // The suite body takes no parameters or its SuiteContext (flag 2).
+    "test.suite": { argTypes: [STRING, F64, STRING, null, STRING, F64, F64], result: VOID },
+    // The trailing string is the hook call's "file:line:col".
+    "test.hook": { argTypes: [F64, null, F64, STRING], result: VOID },
     "test.sub": {
-        argTypes: [TESTCTX_T, STRING, F64, STRING, null, F64, STRING],
+        argTypes: [TESTCTX_T, STRING, F64, STRING, null, F64, STRING, F64, F64, F64],
         result: { kind: "promise", inner: VOID },
     },
-    "test.subEmpty": { argTypes: [TESTCTX_T, STRING, F64, STRING, STRING], result: VOID },
+    "test.subEmpty": {
+        argTypes: [TESTCTX_T, STRING, F64, STRING, F64, STRING, F64, F64, F64],
+        result: VOID,
+    },
     "test.ctxSkip": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxTodo": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxDiagnostic": { argTypes: [TESTCTX_T, STRING], result: VOID },
     "test.ctxName": { argTypes: [TESTCTX_T], result: STRING },
     "test.ctxFullName": { argTypes: [TESTCTX_T], result: STRING },
+    // t.passed, and t.workerId's Number(NODE_TEST_WORKER_ID) with 0 for
+    // undefined.
+    "test.ctxPassed": { argTypes: [TESTCTX_T], result: BOOL },
+    "test.workerId": { argTypes: [], result: F64 },
+    // getTestContext(): whether a test, suite or hook is running in the
+    // current async context, and that context.
+    "test.hasContext": { argTypes: [], result: BOOL },
+    "test.context": { argTypes: [], result: TESTCTX_T },
     // t.before/t.after/t.beforeEach/t.afterEach (which: 0 before, 1 after,
     // 2 beforeEach, 3 afterEach); a throwing t.before is captured on the test.
     "test.ctxHook": { argTypes: [TESTCTX_T, F64, null, F64], result: VOID },
     // t.plan(count), and the count of one t.assert call.
     "test.ctxPlan": { argTypes: [TESTCTX_T, F64], result: VOID },
     "test.ctxCount": { argTypes: [TESTCTX_T], result: VOID },
+    // The mock trackers: the module's `mock` and t.mock keep each mock's
+    // restore closure (moved) for restoreAll and reset.
+    "test.mockTrack": { argTypes: [{ kind: "func", params: [], ret: VOID }], result: VOID },
+    "test.mockRestoreAll": { argTypes: [], result: VOID },
+    "test.mockReset": { argTypes: [], result: VOID },
+    "test.ctxMockTrack": {
+        argTypes: [TESTCTX_T, { kind: "func", params: [], ret: VOID }],
+        result: VOID,
+    },
+    "test.ctxMockRestoreAll": { argTypes: [TESTCTX_T], result: VOID },
+    "test.ctxMockReset": { argTypes: [TESTCTX_T], result: VOID },
+    // mock.timers on the module's `mock` and on t.mock. enable takes one
+    // code per listed API ('T' setTimeout, 'I' setInterval), the `now`
+    // value and its flags (1 given, 2 from a Date). enable, tick, runAll and
+    // setTime throw Node's errors; tick and runAll run timer callbacks.
+    // t.assert.snapshot and fileSnapshot: the escaped, wrapped serialized
+    // value, and the stored value it is compared with (snapshot: the test,
+    // the value, the snapshot file; fileSnapshot: the value, the path).
+    // Both read or, in update mode, record; missing and unreadable
+    // snapshots throw Node's ERR_INVALID_STATE.
+    "test.snapshotValue": { argTypes: [STRING], result: STRING },
+    "test.ctxSnapshot": { argTypes: [TESTCTX_T, STRING, STRING], result: STRING },
+    "test.fileSnapshot": { argTypes: [STRING, STRING], result: STRING },
+    // Node's serializeValue over a dyn array of serializers (undefined for
+    // the default JSON.stringify(value, null, 2)); a throw becomes Node's
+    // "The provided serializers did not generate a string." ERR_INVALID_STATE.
+    "test.snapshotSerialize": { argTypes: [DYN, DYN], result: DYN },
+    "test.mockTimersEnable": { argTypes: [STRING, F64, F64], result: VOID },
+    "test.mockTimersTick": { argTypes: [F64], result: VOID },
+    "test.mockTimersRunAll": { argTypes: [], result: VOID },
+    "test.mockTimersReset": { argTypes: [], result: VOID },
+    "test.mockTimersSetTime": { argTypes: [F64], result: VOID },
+    "test.ctxMockTimersEnable": { argTypes: [TESTCTX_T, STRING, F64, F64], result: VOID },
+    "test.ctxMockTimersTick": { argTypes: [TESTCTX_T, F64], result: VOID },
+    "test.ctxMockTimersRunAll": { argTypes: [TESTCTX_T], result: VOID },
+    "test.ctxMockTimersReset": { argTypes: [TESTCTX_T], result: VOID },
+    "test.ctxMockTimersSetTime": { argTypes: [TESTCTX_T, F64], result: VOID },
     // node:http (scr_http.c over scr_net.c). The handler and the data
     // listeners are program-dependent closures (null slots, checked in the
     // libCall case); reqHeader's result is the interned string|undefined
@@ -1631,7 +1885,31 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * socket POOLING is not modeled (one dial per request); maxSockets
      * accounting is real: over-limit requests defer their dial and queue.
      * MAY THROW. */
-    "http.agentNew": { argTypes: [BOOL, BOOL, F64, F64, F64, F64, F64], result: DYN },
+    "http.agentNew": { argTypes: [BOOL, BOOL, F64, F64, F64, F64, F64, DYN], result: DYN },
+    /** http.globalAgent / https.globalAgent (true): Node's keepAlive global
+     * agent, the one requests without an agent option use. */
+    "http.globalAgent": { argTypes: [BOOL], result: DYN },
+    /** http.request's `signal` option over the fresh request: an aborted
+     * signal destroys it with Node's AbortError now, a later abort event
+     * does the same. A falsy value is ignored; a non-signal throws
+     * ERR_INVALID_ARG_TYPE. */
+    "http.clientSignal": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
+    /** options.signal checked before the request is built (ERR_INVALID_ARG_TYPE). */
+    "http.clientSignalCheck": { argTypes: [DYN], result: VOID },
+    /** https.request's servername option, stored for the construction call
+     * that follows: the TLS name sent and verified, and part of the pooled
+     * socket key. The "https." prefix keeps the TLS unit linked. */
+    "https.nextServername": { argTypes: [STRING], result: VOID },
+    /** The maxHeaderSize option of createServer / http.request: Node's
+     * validateInteger (ERR_OUT_OF_RANGE) then the header size bound.
+     * MAY THROW. */
+    "http.serverMaxHeaderSize": { argTypes: [NETSERVER_T, F64], result: VOID },
+    "http.clientMaxHeaderSize": { argTypes: [HTTPCLIENTREQ_T, F64], result: VOID },
+    /** req.destroy(err): err becomes the request's 'error'. */
+    "http.clientDestroyError": {
+        argTypes: [HTTPCLIENTREQ_T, { kind: "object", className: "%Error" }],
+        result: VOID,
+    },
     /** The agent-threaded request rows: the http.request/https.request
      * shape with a trailing `agent` dyn argument (an Agent handle, false —
      * the one-shot Connection: close dial — or null/undefined for the
@@ -1651,6 +1929,17 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * non-http scheme. */
     "http.requestUrl": { argTypes: [STRING, STRING, BOOL], result: HTTPCLIENTREQ_T },
     "http.requestUrlCb": { argTypes: [STRING, STRING, BOOL, null], result: HTTPCLIENTREQ_T },
+    /** request/get with a runtime options record: a RequestOptions
+     * variable, or a literal that spreads one or sets socketPath. Args
+     * (options, autoEnd[, cb]). The runtime reads the record in the
+     * ClientRequest constructor's order (host/port or socketPath, path,
+     * method, headers, timeout, agent, signal, maxHeaderSize) with Node's
+     * errors, and documented options it does not implement throw the
+     * runtime fence. The "https." pair adds the TLS options. MAY THROW. */
+    "http.requestDyn": { argTypes: [DYN, BOOL], result: HTTPCLIENTREQ_T },
+    "http.requestDynCb": { argTypes: [DYN, BOOL, null], result: HTTPCLIENTREQ_T },
+    "https.requestDyn": { argTypes: [DYN, BOOL], result: HTTPCLIENTREQ_T },
+    "https.requestDynCb": { argTypes: [DYN, BOOL, null], result: HTTPCLIENTREQ_T },
     /** The paused-mode demux surface (portless's first-byte TLS peek:
      * once('readable') + read(1) + unshift + emit('connection')).
      * sockOnReadable registers a zero-param listener (a consumer: arrived
@@ -1696,6 +1985,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** Listeners with a parameter, as dyn functions: close(hadError),
      * write's cb(err) and end's cb. */
     "net.sockOnCloseDyn": { argTypes: [NETSOCKET_T, DYN, BOOL], result: VOID },
+    /** socket.on/once('lookup', listener): the listener (a dyn function)
+     * gets (err, address, family, host) once per resolved address, or once
+     * with the lookup error, before the connect. */
+    "net.sockOnLookup": { argTypes: [NETSOCKET_T, DYN, BOOL], result: VOID },
     "net.sockOnWriteFlush": {
         argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }],
         result: VOID,
@@ -1713,6 +2006,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "net.serverMaxConnectionsSet": { argTypes: [NETSERVER_T, DYN], result: VOID },
     "net.serverDropMaxConnectionGet": { argTypes: [NETSERVER_T], result: DYN },
     "net.serverDropMaxConnectionSet": { argTypes: [NETSERVER_T, DYN], result: VOID },
+    /** net.SocketAddress and net.BlockList (scr_net.c): the constructors
+     * take the argument array; the handles are dyn values. */
+    "net.socketAddressNew": { argTypes: [DYN], result: DYN },
+    "net.socketAddressParse": { argTypes: [DYN], result: DYN },
+    "net.isSocketAddress": { argTypes: [DYN], result: BOOL },
+    "net.blockListNew": { argTypes: [DYN], result: DYN },
+    "net.isBlockList": { argTypes: [DYN], result: BOOL },
+    "net.blockListPrivateRanges": { argTypes: [], result: DYN },
     "net.serverOnDrop": { argTypes: [NETSERVER_T, DYN, BOOL], result: VOID },
     "net.serverGetConnections": { argTypes: [NETSERVER_T, DYN], result: VOID },
     "net.sockReadable": { argTypes: [NETSOCKET_T], result: BOOL },
@@ -1866,6 +2167,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * h2-only split). args are (cert, key) — PEM strings or Buffers. */
     "http2.createSecureServerH2": { argTypes: [null, null, BOOL], result: NETSERVER_T },
     "http.serverOnRequest": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
+    /** server.on('checkContinue' | 'checkExpectation', (req, res)): the
+     * 'request' listener shape; the last argument picks checkExpectation. */
+    "http.serverOnCheck": { argTypes: [NETSERVER_T, null, BOOL, BOOL], result: VOID },
     "http2.serverOnSessionError": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
     /** The guarded absent-session compatibility call remains a no-op. */
     "http2.streamNoop": { argTypes: [], result: VOID },
@@ -2079,12 +2383,18 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL],
         result: VOID,
     },
+    "http.clientOnContinue": {
+        argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL],
+        result: VOID,
+    },
     /** execFileSync/execSync as ONE entry (args: cmd, argv, shell, input,
-     * cwd, hasEnv, envPairs, timeoutMs, stdoutMode, stderrMode — see
-     * scr_runtime.h). Throws Node's exact errors: "Command failed: <cmd>"
+     * cwd, hasEnv, envPairs, timeoutMs, stdoutMode, stderrMode, buffers —
+     * see scr_child.h). Throws Node's exact errors: "Command failed: <cmd>"
      * (+ captured stderr) on non-zero exit or signal death, "spawnSync
      * <file> ENOENT" on spawn failure, "spawnSync <file> ETIMEDOUT" after
-     * the SIGTERM timeout. Result is the captured utf8 stdout (+1). */
+     * the SIGTERM timeout, with Node's status, signal, output, pid, stdout
+     * and stderr properties (Buffer outputs when buffers is set: no
+     * encoding option). Result is the captured utf8 stdout (+1). */
     "cp.execSync": {
         argTypes: [
             STRING,
@@ -2098,6 +2408,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
             F64,
             F64,
             F64,
+            BOOL,
         ],
         result: STRING,
     },
@@ -2159,6 +2470,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** Rest listeners use the checked function bridge to pack event arguments. */
     "child.onDyn": { argTypes: [CHILD_T, STRING, DYN], result: VOID },
     "process.connected": { argTypes: [], result: BOOL },
+    /** Whether this fork child opened its channel; part of process.send's
+     * presence in programs with fork targets. Never throws. */
+    "process.ipcOpen": { argTypes: [], result: BOOL },
     "process.send": { argTypes: [STRING], result: BOOL },
     "process.sendCb": { argTypes: [STRING, null], result: BOOL },
     "process.disconnect": { argTypes: [], result: VOID },
@@ -2167,8 +2481,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** child_process.execFile's callback slice: starts an all-piped child,
      * captures stdout/stderr, and moves the error-first callback into the
      * child registry. The callback shape is program-dependent and checked
-     * by the validator/backends. */
-    "cp.execFile": { argTypes: [STRING, arrayOf(STRING), null], result: CHILD_T },
+     * by the validator/backends. The last argument is exec's shell flag:
+     * the argv is ["-c", command] and failure messages show the command. */
+    "cp.execFile": { argTypes: [STRING, arrayOf(STRING), null, BOOL], result: CHILD_T },
     // spawn's options form: per-slot stdio modes (0 ignore / 1 inherit /
     // 2 fd) with the out/err fds for mode 2, detached, env replacement
     // pairs, cwd ("" = inherit).
@@ -2281,8 +2596,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * queue, end/destroy settle it, writable is a pure state read, and
      * listener callbacks move into the writer registry. */
     "child.stdin": { argTypes: [CHILD_T], result: VOID },
+    /** Under the general stream representation (general-streams.ts), a
+     * stdio read (slot 0, 1 or 2) answers the child's bridged runtime stream
+     * — `Writable | null` for stdin, `Readable | null` otherwise; the bridge
+     * throws when the program lacks the stream unit's boxing helpers. */
+    "child.stdioStream": { argTypes: [CHILD_T, F64], result: VOID },
     // Listener registrations: callback func shapes are program-dependent
-    // (zero-param / Buffer / Buffer-armed union) — the slots pin arity,
+    // (zero-param / Buffer / string / unknown / Buffer-armed union) — the slots pin arity,
     // the stream receiver, and the once-flag.
     "stream.onData": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
     "stream.onDataStr": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
@@ -2302,6 +2622,39 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * stderrWrite paths so buffering and ordering stay identical. Data
      * borrowed; the bool is Node's always-true backpressure signal. */
     "procStream.write": { argTypes: [PROCSTREAM_T, STRING], result: BOOL },
+    /** process.stdout/stderr flowing into a runtime Writable slot under the
+     * general stream representation: an fd-backed Writable (+1) whose
+     * writes take process.stdout.write's synchronous path. */
+    /** A pipeline() stage that is a checked-dynamic value: a boxed native
+     * stream unwraps by identity (+1); anything else throws the given
+     * not-supported message. Typed as a Duplex so every stage position
+     * accepts it; the runtime pipeline checks the stream's real sides. */
+    "stream.unboxDyn": {
+        argTypes: [DYN, STRING],
+        result: { kind: "object", className: "%Duplex" },
+    },
+    /** Checked-dynamic stream slots (dyn-streams.ts): the native stream a
+     * checked-dynamic value boxes (+1) — a runtime stream with the readable
+     * (1) or writable (2) side — or null for any other value. Never throws;
+     * the result union is `%Readable | null` or `%Writable | null`. */
+    "stream.dynNative": { argTypes: [DYN, F64], result: VOID },
+    /** stream.dynNative for a pipe or unpipe destination: also a
+     * constructor-function stream's runtime stream, in programs that link
+     * that unit, unless it overrides write() or end(). */
+    "stream.dynNativePipe": { argTypes: [DYN, F64], result: VOID },
+    /** readable.pipe(destination, end) into a checked-dynamic destination
+     * that is not a native stream: [source, the source boxed, destination,
+     * end]. Node's pipe listener protocol over the destination's members
+     * (scr_stream_dyn.c); throws what those members throw. */
+    "stream.pipeDyn": { argTypes: [null, DYN, DYN, BOOL], result: VOID },
+    /** readable.unpipe(destination) for a checked-dynamic destination that
+     * is not a native stream: [source, destination]. Unpipes the pipe
+     * stream.pipeDyn registered into it, if any (scr_stream_dyn.c). */
+    "stream.unpipeDyn": { argTypes: [null, DYN], result: VOID },
+    "stream.stdioWritable": {
+        argTypes: [PROCSTREAM_T],
+        result: { kind: "object", className: "%Writable" },
+    },
     "child.killed": { argTypes: [CHILD_T], result: BOOL },
     "child.kill": { argTypes: [CHILD_T, STRING], result: BOOL },
     "child.killNum": { argTypes: [CHILD_T, F64], result: BOOL },
@@ -2336,6 +2689,15 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * finalizes the handle and returns either a Buffer or encoded string. */
     "crypto.native": { argTypes: [], result: DYN },
     "crypto.hashNew": { argTypes: [STRING], result: CRYPTOHASH_T },
+    /** The Transform a Hash or Hmac reads and writes as a stream (+1,
+     * created on first use and owned by the value; scr_stream.c). The Piped
+     * form, for pipe destinations and pipeline stages, also keeps the value
+     * alive until the stream flushes or is destroyed. */
+    "crypto.hashStream": { argTypes: [null], result: { kind: "object", className: "%Transform" } },
+    "crypto.hashStreamPiped": {
+        argTypes: [null],
+        result: { kind: "object", className: "%Transform" },
+    },
     /** createCipheriv (false) / createDecipheriv (true) over checked-dynamic
      * cipher, key, iv and options arguments (scr_cipher.c): a native
      * Cipheriv/Decipheriv handle whose methods dispatch through dynInvoke. */
@@ -2378,6 +2740,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * whether min was given. */
     "crypto.randomFillView": { argTypes: [null, F64, F64], result: BYTES_U8 },
     "crypto.randomFillViewRest": { argTypes: [null, F64], result: BYTES_U8 },
+    /** crypto.getRandomValues: a view returns itself at its own type (the
+     * float/size DOMExceptions are thrown at run time); any other value
+     * takes the checked form. */
+    "crypto.getRandomValues": { argTypes: [null], result: BYTES_U8 },
+    "crypto.getRandomValuesDyn": { argTypes: [DYN], result: DYN },
     "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 },
@@ -2390,6 +2757,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "crypto.generateKeyCb": { argTypes: [DYN, DYN, null], result: VOID },
     "crypto.keyObjectInput": { argTypes: [DYN], result: BYTES_U8 },
     "crypto.isKeyObject": { argTypes: [DYN], result: BOOL },
+    /** WebCrypto (scr_webcrypto.c): each method takes its argument vector as
+     * one dyn array and answers a promise that argument and validation
+     * failures reject. CryptoKey values are native handles. */
+    "webcrypto.importKey": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
+    "webcrypto.sign": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
+    "webcrypto.verify": { argTypes: [DYN], result: { kind: "promise", inner: BOOL } },
+    "webcrypto.digest": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
+    "webcrypto.isCryptoKey": { 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 },
@@ -2398,6 +2773,25 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "crypto.hkdfCb": { argTypes: [STRING, BYTES_U8, BYTES_U8, BYTES_U8, F64, null], result: VOID },
     "crypto.scrypt": { argTypes: [BYTES_U8, BYTES_U8, F64, DYN], result: BYTES_U8 },
     "crypto.scryptCb": { argTypes: [BYTES_U8, BYTES_U8, F64, DYN, null], result: VOID },
+    /** util.promisify over the callback forms: the callback form's
+     * arguments without the callback → a promise the callback form settles,
+     * or rejected with an argument error; never throws. The result's value
+     * type is the declared one (a Buffer, the filled view, a number, or a
+     * checked-dynamic value); the validator checks it. */
+    "crypto.randomBytesPromise": { argTypes: [F64], result: VOID },
+    "crypto.pbkdf2Promise": { argTypes: [BYTES_U8, BYTES_U8, F64, F64, STRING], result: VOID },
+    "crypto.scryptPromise": { argTypes: [BYTES_U8, BYTES_U8, F64, DYN], result: VOID },
+    "crypto.hkdfPromise": { argTypes: [STRING, BYTES_U8, BYTES_U8, BYTES_U8, F64], result: VOID },
+    "crypto.randomFillPromise": { argTypes: [null, F64, F64, F64], result: VOID },
+    "crypto.randomFillPromiseDyn": { argTypes: [DYN, DYN, DYN, F64], result: VOID },
+    "crypto.randomIntPromise": { argTypes: [F64, F64, F64], result: VOID },
+    "crypto.generateKeyPromise": { argTypes: [DYN, DYN], result: VOID },
+    /** util.promisify(dns.lookup) and util.promisify(dns.lookupService):
+     * [hostname, options] and [address, port] → a promise of the
+     * checked-dynamic result object (the address array with options.all),
+     * or rejected with the error; never throws. */
+    "dns.lookupPromise": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "dns.lookupServicePromise": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     // The Buffer statics and the fs/zlib Buffer forms: fixed always-u8
     // signatures (Buffer IS a Uint8Array — one bytes kind).
     /** The Buffer statics with fixed (always-u8) signatures. fromStr is
@@ -2409,6 +2803,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "buffer.fromStr": { argTypes: [STRING, STRING], result: BYTES_U8 },
     "buffer.fromStrChecked": { argTypes: [STRING, STRING], result: BYTES_U8 },
     "buffer.brand": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    /** Buffer.isBuffer over a typed view: whether the view carries the
+     * Buffer brand (any element kind; only Buffers do). Never throws. */
+    "buffer.isBranded": { argTypes: [null], result: BOOL },
     /** Buffer.from on checked-native strings, bytes, arrays and data-only
      * array-like/Buffer-JSON objects. The encoding is a normalized literal;
      * non-string inputs ignore it. Copies the input and may throw during
@@ -2416,6 +2813,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * opaque reference inputs retain explicit runtime refusals. */
     "buffer.fromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
     "buffer.concat": { argTypes: [arrayOf(BYTES_U8)], result: BYTES_U8 },
+    "buffer.concatDyn": { argTypes: [DYN], result: BYTES_U8 },
     /** The pooled Buffer factories (Node's allocate/fromStringFast/
      * fromArrayLike): allocUnsafe, Buffer.from of strings, Uint8Arrays,
      * number[] and checked values, and concat return views into the
@@ -2442,6 +2840,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * zero-padded to the total. THROWS Node's 'length' RangeError on a
      * negative/non-integer total (may-throw seed). */
     "buffer.concatLen": { argTypes: [arrayOf(BYTES_U8), F64], result: BYTES_U8 },
+    "buffer.concatLenDyn": { argTypes: [DYN, F64], result: BYTES_U8 },
     // The checked-dynamic compare/equals validators (Node's argument
     // ladders over dyn-boxed invalid-input probes).
     /** The checked-dynamic compare/equals validators (scr_bytes_io.c) —
@@ -2563,6 +2962,20 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "zlib.gunzipCb": { argTypes: [BYTES_U8, null], result: VOID },
     "zlib.unzipCb": { argTypes: [BYTES_U8, null], result: VOID },
     "zlib.crc32": { argTypes: [BYTES_U8, F64], result: F64 },
+    /** The one-shot forms with an options value: node_zlib_mode, the input,
+     * the options (validated at runtime with Node's ladder). The Cb form
+     * takes the program-shaped (Error | null, Buffer) callback, which moves. */
+    "zlib.syncOpts": { argTypes: [F64, BYTES_U8, DYN], result: BYTES_U8 },
+    "zlib.cbOpts": { argTypes: [F64, BYTES_U8, DYN, null], result: VOID },
+    /** The checked-dynamic input twins (the JS lane's untyped data). */
+    "zlib.syncOptsDyn": { argTypes: [F64, DYN, DYN], result: BYTES_U8 },
+    "zlib.cbOptsDyn": { argTypes: [F64, DYN, DYN, null], result: VOID },
+    /** util.promisify over the callback one-shots: [mode, data, options]
+     * like zlib.cbOpts → a promise the worker-pool run settles with the
+     * Buffer or the callback form's Error. An options or input error rejects
+     * it; never throws. The Dyn twin takes the JS lane's untyped data. */
+    "zlib.promise": { argTypes: [F64, BYTES_U8, DYN], result: { kind: "promise", inner: BYTES_U8 } },
+    "zlib.promiseDyn": { argTypes: [F64, DYN, DYN], result: { kind: "promise", inner: BYTES_U8 } },
     /** The stream classes (scr_zlib_stream.c, linked with the stream unit):
      * streamNew takes Node's node_zlib_mode number and the options value
      * (undefined when absent), validates it with Node's ladder, and answers
@@ -2571,6 +2984,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * receivers are borrowed. */
     "zlib.streamNew": { argTypes: [F64, DYN], result: VOID },
     "zlib.streamBytesWritten": { argTypes: [null], result: F64 },
+    /** `stream instanceof zlib.Gzip`: the borrowed stream and the class's
+     * node_zlib_mode; true when the stream is a zlib stream of that mode. */
+    "zlib.streamIs": { argTypes: [null, F64], result: BOOL },
     "zlib.streamFlush": { argTypes: [null, DYN], result: VOID },
     "zlib.streamFlushCb": { argTypes: [null, DYN, null], result: VOID },
     "zlib.streamParams": { argTypes: [null, DYN, DYN], result: VOID },
@@ -2619,6 +3035,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fsp.rmdir": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
     "fsp.link": { argTypes: [DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fsp.symlink": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
+    "fsp.cp": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
     "fsp.readlink": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "fsp.statfs": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "fsp.readlinkStr": { argTypes: [DYN, DYN], result: { kind: "promise", inner: STRING } },
@@ -2697,6 +3114,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "fileHandle.stat": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: STATS_T } },
     "process.argv": { argTypes: [], result: arrayOf(STRING) },
+    // The Node runtime flag a node:test binary took out of process.argv
+    // (--test-update-snapshots), or [] — a fresh array per read.
+    "process.execArgv": { argTypes: [], result: arrayOf(STRING) },
     "process.platform": { argTypes: [], result: STRING },
     // The one libCall whose result type is program-dependent (union ids are
     // per-module): the `result` here is a placeholder — the libCall case
@@ -2725,8 +3145,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "process.exit": { argTypes: [F64], result: VOID },
     /** Numeric process.exitCode write (integer validation, implicit exit status). */
     "process.setExitCode": { argTypes: [F64], result: VOID },
+    /** The process.exitCode write of a program that also reads the
+     * property: the same validation, and the code counts as assigned. */
+    "process.setExitCodeTracked": { argTypes: [F64], result: VOID },
     /** The code for process.exit() with no argument, or zero when unset. */
     "process.currentExitCode": { argTypes: [], result: F64 },
+    /** Whether process.exitCode reads a code rather than undefined. Never throws. */
+    "process.hasExitCode": { argTypes: [], result: BOOL },
     "process.cwd": { argTypes: [], result: STRING },
     /** getpid(2) / getuid(2): zero args → f64. POSIX-only target, so both
      * always answer (the checker's `getuid?` optionality covers Windows —
@@ -2818,6 +3243,23 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "error.hasCause": { argTypes: [null], result: BOOL },
     /** Assignment borrows both operands and retains the new cause. */
     "error.setCause": { argTypes: [null, DYN], result: VOID },
+    /** `err.code = s` on an error-hierarchy receiver: the code slot that
+     * error.code reads and coded throws stamp. Borrows both; never throws. */
+    "error.setCode": { argTypes: [null, STRING], result: VOID },
+    /** `err.code = v` with a value that is not statically a string: strings
+     * take the code slot, anything else clears it and sets the dynamic own
+     * property. Borrows both; never throws. */
+    "error.setCodeDyn": { argTypes: [null, DYN], result: VOID },
+    /** `Object.assign(err, ...sources)` onto an error-hierarchy receiver
+     * (args: the error, a dyn array of the sources): the own-member copy
+     * onto its checked-dynamic node, then the typed slots (name, message,
+     * stack, cause, code) re-read from it. Throws what the copy throws. */
+    "error.assign": { argTypes: [null, DYN], result: VOID },
+    /** `key in err` for a key no compiled class of the receiver declares
+     * (args: the error, the key): a runtime-set own property (Object.assign,
+     * throw-site fields, dynamic writes) or an Object.prototype member. */
+    "error.hasKey": { argTypes: [null, STRING], result: BOOL },
+    "error.hasCode": { argTypes: [null], result: BOOL },
     "error.defineCause": { argTypes: [null, DYN], result: VOID },
     "error.deleteCause": { argTypes: [null], result: VOID },
     /** The compiler-resolved Node-parity throw for always-throwing lowered
@@ -2850,6 +3292,29 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.compare": { argTypes: [DYN, DYN, STRING], result: BOOL },
     "dyn.bitwise": { argTypes: [DYN, DYN, STRING], result: DYN },
     "dyn.proxyNew": { argTypes: [DYN, DYN], result: DYN },
+    /* Dynamic-tier values (jsval; two-tier design stage S3). The jsval pass
+     * (ir/jsval.ts) introduces these in dynamic-tier functions only; the
+     * runtime is scr_js_value.c. Arguments are borrowed and results owned,
+     * like every libCall. Boundary conversions: js.fromDyn (a cell keeps its
+     * identity), js.toDyn (an immediate is boxed), js.fromF64/fromBool/
+     * fromStr/fromBigInt (the design's toJs: immediates, and strings and
+     * BigInts under a tag without a copy) and js.toF64 (fromJs to number: dynCheck's
+     * number check and TypeError). The operators are the dyn.* operators
+     * over jsvals, with identical JS semantics. */
+    "js.fromDyn": { argTypes: [DYN], result: JSVAL },
+    "js.toDyn": { argTypes: [JSVAL], result: DYN },
+    "js.fromF64": { argTypes: [F64], result: JSVAL },
+    "js.fromBool": { argTypes: [BOOL], result: JSVAL },
+    "js.fromStr": { argTypes: [STRING], result: JSVAL },
+    "js.fromBigInt": { argTypes: [BIGINT_T], result: JSVAL },
+    "js.toF64": { argTypes: [JSVAL], result: F64 },
+    "js.add": { argTypes: [JSVAL, JSVAL], result: JSVAL },
+    "js.arithmetic": { argTypes: [JSVAL, JSVAL, STRING], result: JSVAL },
+    "js.bitwise": { argTypes: [JSVAL, JSVAL, STRING], result: JSVAL },
+    "js.compare": { argTypes: [JSVAL, JSVAL, STRING], result: BOOL },
+    "js.toNumeric": { argTypes: [JSVAL], result: JSVAL },
+    "js.increment": { argTypes: [JSVAL, BOOL], result: JSVAL },
+    "js.toNumberCoerce": { argTypes: [JSVAL], result: F64 },
     // Always throws; the result is the READ's declared type (a typed dummy
     // the unwind abandons) — the libCall case skips the result check.
     /** A read of a `declare`d const NOTHING defines (the bundler-define
@@ -2908,6 +3373,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** SameValue over checked values, including NaN, signed zero and reference identity. */
     "dyn.sameValue": { argTypes: [DYN, DYN], result: BOOL },
     "error.stack": { argTypes: [null], result: STRING },
+    "error.setStack": { argTypes: [null, STRING], result: VOID },
     "error.stackLimitGet": { argTypes: [], result: F64 },
     "error.stackLimitSet": { argTypes: [F64], result: VOID },
     // Receiver (any error-hierarchy object) and the program-dependent
@@ -2962,6 +3428,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "error.aggregateSetErrors": { argTypes: [null, DYN], result: VOID },
     "error.aggregateErrors": { argTypes: [null], result: DYN },
+    /** `new SuppressedError(error, suppressed, message?)` (scr_json.c): all
+     * three dyn and borrowed; the message conversion can throw. Returns an
+     * owned %SuppressedError. */
+    "error.newSuppressed": {
+        argTypes: [DYN, DYN, DYN],
+        result: { kind: "object", className: "%SuppressedError" },
+    },
     /** `d instanceof TypeError` (and the other BUILTIN error classes) on a
      * checked-dynamic value (scr_json.c): the from_error cache holds the
      * dyn↔error identity edge, so the test resolves the runtime error and
@@ -3006,6 +3479,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "arrayBuffer.viewU8": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
     "arrayBuffer.viewU32": { argTypes: [DYN, DYN, DYN], result: bytesOf("u32") },
     "arrayBuffer.viewI32": { argTypes: [DYN, DYN, DYN], result: bytesOf("i32") },
+    "arrayBuffer.viewF16": { argTypes: [DYN, DYN, DYN], result: bytesOf("f16") },
     "arrayBuffer.viewF32": { argTypes: [DYN, DYN, DYN], result: bytesOf("f32") },
     "arrayBuffer.viewF64": { argTypes: [DYN, DYN, DYN], result: bytesOf("f64") },
     "arrayBuffer.viewDV": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
@@ -3051,6 +3525,19 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.packPushSpreadIter": { argTypes: [DYN, DYN], result: VOID },
     "dyn.reflectApply": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.reflectGet": { argTypes: [DYN, DYN, DYN], result: DYN },
+    /** `using` / `await using` with a dyn value (scr_json.c): usingMethod
+     * runs the declaration's checks and answers what usingDispose calls at
+     * scope exit (undefined for a null or undefined value). The bool selects
+     * `await using`. Both throw Node's TypeErrors or the method's error. */
+    "dyn.usingMethod": { argTypes: [DYN, BOOL], result: DYN },
+    "dyn.usingDispose": { argTypes: [DYN, DYN], result: DYN },
+    /** DisposableStack (scr_symbol.c): a new stack handle; whether a value is
+     * one; and `stack.use(value)` for a class instance, registering the
+     * compiler's disposal function for it. The last throws Node's
+     * ReferenceError on a disposed stack. */
+    "disposable.stackNew": { argTypes: [], result: DYN },
+    "disposable.stackIs": { argTypes: [DYN], result: BOOL },
+    "disposable.stackUseCallback": { argTypes: [DYN, DYN, DYN], result: BOOL },
     "dyn.reflectSet": { argTypes: [DYN, DYN, DYN, DYN], result: BOOL },
     "dyn.reflectDefine": { argTypes: [DYN, DYN, DYN], result: BOOL },
     "dyn.abstractEq": { argTypes: [DYN, DYN], result: BOOL },
@@ -3064,6 +3551,20 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.classPrototype": { argTypes: [DYN, DYN], result: DYN },
     "dyn.classBasePrototype": { argTypes: [DYN], result: DYN },
     "dyn.classInherit": { argTypes: [DYN, DYN], result: DYN },
+    /** EventEmitter (0), Stream (1), Readable (2), Writable (3), Duplex (4),
+     * Transform (5) and PassThrough (6) as untyped constructor values, one
+     * per thread (scr_dyn_builtin_class.c). */
+    "dyn.builtinClass": { argTypes: [F64], result: DYN },
+    /** The stream classes (2-6 above) with their stream half: constructor
+     * functions over them get native stream state
+     * (scr_dyn_builtin_stream.c). */
+    "dyn.builtinStreamClass": { argTypes: [F64], result: DYN },
+    /** `value instanceof C` for those constructors, over the value's
+     * prototype chain. */
+    "dyn.builtinInstanceOf": { argTypes: [DYN, F64], result: BOOL },
+    /** `value instanceof f` for an untyped constructor function: the
+     * prototype chain against f.prototype. */
+    "dyn.functionInstanceOf": { argTypes: [DYN, DYN], result: BOOL },
     "dyn.classSuper": { argTypes: [DYN, DYN, DYN], result: VOID },
     "dyn.assignPrototype": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.definePrototypeProps": { argTypes: [DYN, DYN, DYN], result: DYN },
@@ -3126,6 +3627,8 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 },
+    // `.index` / `.input` (args[1]) of a match result. Borrowed; never throws.
+    "regex.resultProp": { argTypes: [arrayOf(STRING), STRING], result: DYN },
     // 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
@@ -3152,6 +3655,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * throws err when unhandled. count/countFn/names/listeners/getMax/
      * setMax/setDefaultMax/getDefaultMax are the introspection surface. */
     "emitter.new": { argTypes: [], result: VOID },
+    /** `x.constructor.name` of an emitter or stream (a borrowed object of
+     * EventEmitter's hierarchy): the +1 class name the instance records. */
+    "emitter.className": { argTypes: [null], result: STRING },
     "emitter.ctor": { argTypes: [null], result: VOID },
     "emitter.on": { argTypes: [null, STRING, null, BOOL, BOOL], result: VOID },
     "emitter.off": { argTypes: [null, STRING, null], result: VOID },
@@ -3186,6 +3692,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "emitter.getMax": { argTypes: [null], result: F64 },
     "emitter.setDefaultMax": { argTypes: [F64], result: VOID },
     "emitter.getDefaultMax": { argTypes: [], result: F64 },
+    // The ES module namespace's copy of defaultMaxListeners, and
+    // module.syncBuiltinESMExports() refreshing it.
+    "emitter.esmDefaultMax": { argTypes: [], result: F64 },
+    "emitter.esmSync": { argTypes: [], result: VOID },
     /** 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 },
@@ -3212,7 +3722,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * returns the below-hwm answer. readable.read: (recv, size — -1 for
      * absent) → Buffer|null union. pause/resume return recv +1 (`this`);
      * isPaused answers the flag. readable.pipe: (recv, dst, end) → dst +1,
-     * fires 'pipe' on dst; readable.unpipe (recv[, dst]) → recv +1.
+     * fires 'pipe' on dst; readable.pipeGeneral: the same, with `end` off
+     * when dst is the converted process.stdout / process.stderr;
+     * readable.unpipe (recv[, dst]) → recv +1.
      * writable.write/writeStr: (recv, chunk[, cb]) → below-hwm bool (cb
      * MOVES when present, called after the user write completes).
      * writable.end: (recv, flags[, chunk][, cb]) → recv +1. cork/uncork are
@@ -3370,11 +3882,16 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * error. The Dyn twin boxes chunks by runtime tag (the JS lane).
      * readable.fromArr is Readable.from over a typed array, string or
      * Buffer: [array, SCR_FROM_* flags, highWaterMark]. readable.fromDyn is
-     * the JS lane's [source, options]. */
+     * Readable.from over a checked-dynamic source: [source, options].
+     * readable.fromIter is Readable.from over a class iterator, already
+     * opened: [checked-dynamic { next } object, flags, highWaterMark];
+     * readable.fromAsyncIter is the async class iterator's twin. */
     "readable.nextChunk": { argTypes: [null], result: VOID },
     "readable.nextChunkDyn": { argTypes: [null], result: VOID },
     "readable.fromArr": { argTypes: [null, F64, F64], result: VOID },
     "readable.fromDyn": { argTypes: [DYN, DYN], result: VOID },
+    "readable.fromIter": { argTypes: [DYN, F64, F64], result: VOID },
+    "readable.fromAsyncIter": { argTypes: [DYN, F64, F64], result: VOID },
     /** Readable.from over a compiled generator: [generator, next, return,
      * throw, flags, highWaterMark] (sync) or [generator, next, read,
      * return, throw, flags, highWaterMark] (async), the helpers being the
@@ -3405,6 +3922,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "readable.resume": { argTypes: [null], result: VOID },
     "readable.isPaused": { argTypes: [null], result: BOOL },
     "readable.pipe": { argTypes: [null, null, BOOL], result: VOID },
+    "readable.pipeGeneral": { argTypes: [null, null, BOOL], result: VOID },
     "readable.unpipe": { argTypes: [null], result: VOID },
     "readable.flowing": { argTypes: [null], result: VOID },
     "writable.write": { argTypes: [null, BYTES_U8], result: BOOL },
@@ -3576,18 +4094,25 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "insp.jsonDyn": { argTypes: [DYN], result: STRING },
     "insp.str": { argTypes: [STRING], result: STRING },
     "insp.regex": { argTypes: [REGEX], result: STRING },
+    /** A Date's inspect text: toISOString(), or "Invalid Date". */
+    "insp.date": { argTypes: [DATE_T], result: STRING },
     "insp.buffer": { argTypes: [BYTES_U8], result: STRING },
+    /** A numeric typed array that is not a Buffer (any element kind). */
+    "insp.typedArray": { argTypes: [null, F64, F64], result: STRING },
     "insp.error": { argTypes: [null, F64, F64], result: STRING },
     "insp.dyn": { argTypes: [DYN, F64, F64], result: STRING },
     "insp.dynS": { argTypes: [DYN, F64], result: STRING },
     "insp.begin": { argTypes: [F64], result: VOID },
+    /** util.inspect's breakLength, compact (0 for false) and sorted for the
+     * renders that follow; the call site restores 80, 3 and false afterwards. */
+    "insp.layout": { argTypes: [F64, F64, BOOL], result: VOID },
     "insp.entry": { argTypes: [STRING, BOOL], result: VOID },
     // Circular references: the receiver slot is program-dependent (any
     // cycle-capable record/array/map/class type — the insp.error precedent).
     /* Circular references over cycle-capable composites (recursive record/
      * class types): circCheck answers a value's circular id when it is
      * already on the traversal stack (0 otherwise), seenPush/refWrap
-     * bracket the frame (refWrap adds Node's "<ref *N> " prefix to values
+     * bracket the frame (insp.end adds Node's "<ref *N> " prefix to values
      * the walk found circular), circular renders "[Circular *N]". */
     "insp.circCheck": { argTypes: [null], result: F64 },
     "insp.seenPush": { argTypes: [null], result: VOID },
@@ -3619,6 +4144,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "strdec.write": { argTypes: [STRING, F64, BYTES_U8], result: STRING },
     "strdec.next": { argTypes: [STRING, F64, BYTES_U8], result: F64 },
     "strdec.end": { argTypes: [STRING, F64], result: STRING },
+    /** A runtime encoding argument's canonical name (Node's normalizeEncoding:
+     * nullish and "" are utf8); an unknown name throws ERR_UNKNOWN_ENCODING. */
+    "strdec.encoding": { argTypes: [DYN], result: STRING },
     // node:readline: the interface handle is f64; the callbacks' func types
     // are program-dependent (the emitter picks the adapter by parameter
     // count), so those slots are null like child.onExit's.
@@ -3649,17 +4177,90 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [F64, STRING, DYN],
         result: { kind: "promise", inner: STRING },
     },
+    /** The question forms with a checked-dynamic query (a JavaScript value
+     * that need not be a string). */
+    "rl.questionDyn": { argTypes: [F64, DYN, null], result: VOID },
+    "rl.questionAsyncDyn": { argTypes: [F64, DYN], result: { kind: "promise", inner: STRING } },
+    "rl.questionAsyncSignalDyn": {
+        argTypes: [F64, DYN, DYN],
+        result: { kind: "promise", inner: STRING },
+    },
     "rl.close": { argTypes: [F64], result: VOID },
     "rl.pause": { argTypes: [F64], result: VOID },
     "rl.resume": { argTypes: [F64], result: VOID },
     "rl.prompt": { argTypes: [F64], result: VOID },
+    /** prompt(preserveCursor): [handle, preserveCursor] */
+    "rl.promptWith": { argTypes: [F64, BOOL], result: VOID },
     "rl.setPrompt": { argTypes: [F64, STRING], result: VOID },
+    "rl.setPromptDyn": { argTypes: [F64, DYN], result: VOID },
     "rl.getPrompt": { argTypes: [F64], result: STRING },
     "rl.write": { argTypes: [F64, STRING], result: VOID },
+    /** write(data, key): [handle, hasData, data, hasKey, hasName, name,
+     * ctrl, meta, shift] */
+    "rl.writeKey": {
+        argTypes: [F64, BOOL, STRING, BOOL, BOOL, STRING, BOOL, BOOL, BOOL],
+        result: VOID,
+    },
     "rl.on": { argTypes: [F64, F64, null, BOOL], result: VOID },
     "rl.iterOpen": { argTypes: [F64], result: VOID },
     "rl.iterNext": { argTypes: [F64], result: { kind: "promise", inner: DYN } },
     "rl.iterReturn": { argTypes: [F64], result: VOID },
+    /** createInterface's history and editing options (scr_rl_check_options:
+     * [flags, tabSize, escapeCodeTimeout, historySize], may throw;
+     * rl.setOptions: [handle, flags, historySize, removeHistoryDuplicates,
+     * tabSize, escapeCodeTimeout]; rl.setHistory: [handle, history]) and
+     * the member reads (rl.history answers the array, rl.numProp the
+     * numeric member by number). */
+    "rl.checkOptions": { argTypes: [F64, F64, F64, F64], result: VOID },
+    "rl.checkCompleter": { argTypes: [DYN], result: VOID },
+    "rl.setOptions": { argTypes: [F64, F64, F64, BOOL, F64, F64], result: VOID },
+    "rl.setHistory": { argTypes: [F64, arrayOf(STRING)], result: VOID },
+    "rl.history": { argTypes: [F64], result: arrayOf(STRING) },
+    "rl.numProp": { argTypes: [F64, F64], result: F64 },
+    /** Terminal mode (scr_readline_tty.c): rl.terminal: [handle, mode (0
+     * the option's value, 2 output.isTTY of process.stdout), terminal,
+     * completer (undefined when absent), readline/promises], emitted with
+     * scr_insp_dyn when there is a completer; the line, terminal and cursor
+     * members. */
+    "rl.terminal": { argTypes: [F64, F64, BOOL, DYN, BOOL], result: VOID },
+    "rl.line": { argTypes: [F64], result: STRING },
+    "rl.isTerminal": { argTypes: [F64], result: BOOL },
+    "rl.isPromises": { argTypes: [F64], result: BOOL },
+    /** createInterface's input or output as a checked-dynamic value:
+     * [value, output] — the stream; refused when it is not one. */
+    "rl.inputFromDyn": { argTypes: [DYN, BOOL], result: { kind: "object", className: "%Readable" } },
+    "rl.outputFromDyn": {
+        argTypes: [DYN, BOOL],
+        result: { kind: "object", className: "%Writable" },
+    },
+    "rl.cursor": { argTypes: [F64], result: F64 },
+    /** readline.cursorTo / moveCursor / clearLine / clearScreenDown: rl.seq
+     * [kind (0-3), the first and second numbers, whether the second is
+     * given] answers the data to write after the argument checks (may
+     * throw); rl.moves [dx, dy] says whether moveCursor writes. */
+    "rl.seq": { argTypes: [F64, F64, F64, BOOL], result: STRING },
+    "rl.moves": { argTypes: [F64, F64], result: BOOL },
+    /** getCursorPos() (scr_readline_tty.c, linked through the regex unit
+     * like rl.terminal): [handle, 0 rows | 1 cols] */
+    "rl.cursorPos": { argTypes: [F64, F64], result: F64 },
+    /** readline.emitKeypressEvents (scr_readline_tty.c): rl.keypressStdin
+     * [interface (0: none), escapeCodeTimeout (NaN: the interface's or
+     * 500)], rl.keypressStream [stream, interface, timeout]. */
+    "rl.keypressStdin": { argTypes: [F64, F64], result: VOID },
+    "rl.keypressStream": { argTypes: [null, F64, F64], result: VOID },
+    /** readline/promises Readline over an f64 handle: rl.uiOpen [fd (1
+     * stdout, 2 stderr), autoCommit], rl.uiOpenStream [stream, autoCommit]
+     * (isWritable, may throw); the actions take [handle, ...numbers] (the
+     * checks may throw; cursorTo: [handle, x, whether y is given, y]);
+     * rl.uiCommit answers a promise<void>. */
+    "rl.uiOpen": { argTypes: [F64, BOOL], result: F64 },
+    "rl.uiOpenStream": { argTypes: [null, BOOL], result: F64 },
+    "rl.uiCursorTo": { argTypes: [F64, F64, BOOL, F64], result: VOID },
+    "rl.uiMoveCursor": { argTypes: [F64, F64, F64], result: VOID },
+    "rl.uiClearLine": { argTypes: [F64, F64], result: VOID },
+    "rl.uiClearScreenDown": { argTypes: [F64], result: VOID },
+    "rl.uiRollback": { argTypes: [F64], result: VOID },
+    "rl.uiCommit": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
     /** node:timers/promises — the promisified pair (scr_async.c, beside
      * the timer heap they ride): tp.setTimeout: [ms] → a pending void
      * promise a one-shot heap timer fulfills (the loop's timer phase, FIFO
@@ -3667,17 +4268,33 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * through the immediate queue (fires before due timers of later loop
      * turns, Node's check phase). Neither throws. */
     "tp.setTimeout": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
+    // scheduler.wait(delay): tp.setTimeout's promise. It throws Node's
+    // ERR_INVALID_THIS once mock.timers has restored the real scheduler.wait.
+    "tp.schedulerWait": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
     "tp.setImmediate": { argTypes: [], result: { kind: "promise", inner: VOID } },
     /** events.once (scr_events_emitter.c): [emitter, name, boxer,
      * errorBoxer, listenForError] → a pending promise of any[]; the boxers
      * turn the event's and the 'error' tuple into that array. */
     "events.once": { argTypes: [null, STRING, null, null, BOOL], result: VOID },
+    /** events.once(emitter, name, { signal }) (scr_events_once_signal.c):
+     * events.once's arguments plus the checked-dynamic signal (an
+     * AbortSignal or undefined). */
+    "events.onceSignal": { argTypes: [null, STRING, null, null, BOOL, DYN], result: VOID },
     /** The resolve-value forms: [ms?, value, ref] → a pending promise of the
      * value's type that copies the borrowed already-resolved `value` promise
      * when the timer (or immediate) fires; ref false unrefs it. The result
      * type follows the value promise. */
     "tp.setTimeoutValue": { argTypes: [F64, null, BOOL], result: VOID },
     "tp.setImmediateValue": { argTypes: [null, BOOL], result: VOID },
+    /** The same with options.signal (a checked-dynamic AbortSignal or
+     * undefined) last: an abort clears the timer and rejects with an
+     * AbortError (scr_event_target.c). */
+    "tp.setTimeoutSignal": { argTypes: [F64, null, BOOL, DYN], result: VOID },
+    "tp.setImmediateSignal": { argTypes: [null, BOOL, DYN], result: VOID },
+    /** scheduler.wait(delay, options): tp.setTimeoutValue's and
+     * tp.setTimeoutSignal's shapes, with tp.schedulerWait's throws. */
+    "tp.schedulerWaitValue": { argTypes: [F64, null, BOOL], result: VOID },
+    "tp.schedulerWaitSignal": { argTypes: [F64, null, BOOL, DYN], result: VOID },
     /** node:diagnostics_channel (scr_dc.c, linked when any dc.* appears —
      * the zlib gating precedent): a process-global name→channel registry;
      * channel values are f64 handles (type-mapper.ts maps Channel to F64, the
@@ -3773,6 +4390,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * warnings and DeprecationWarning emissions read their truthiness. */
     "process.deprecationFlag": { argTypes: [F64], result: DYN },
     "process.setDeprecationFlag": { argTypes: [F64, DYN], result: VOID },
+    "process.setEmitWarning": { argTypes: [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
@@ -3830,6 +4448,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "date.valueOf": { argTypes: [DATE_T], result: F64 },
     "date.toISOString": { argTypes: [F64], result: STRING },
     "date.toISOStringValue": { argTypes: [DATE_T], result: STRING },
+    /** Date.prototype.toUTCString over a stored Date ("Invalid Date" for
+     * NaN; never throws). */
+    "date.toUTCString": { argTypes: [DATE_T], result: STRING },
     "date.getFullYear": { argTypes: [DATE_T], result: F64 },
     "date.getUTCFullYear": { argTypes: [DATE_T], result: F64 },
     "date.getMonth": { argTypes: [DATE_T], result: F64 },
@@ -3847,14 +4468,17 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "date.getMilliseconds": { argTypes: [DATE_T], result: F64 },
     "date.getUTCMilliseconds": { argTypes: [DATE_T], result: F64 },
     "date.getTimezoneOffset": { argTypes: [DATE_T], result: F64 },
+    /** Date.prototype.toString / toDateString / toTimeString and String(date):
+     * V8's local-time formats with the host zone's long name, "Invalid Date"
+     * for an invalid date. Owned (+1) string; never throws. */
+    "date.toString": { argTypes: [DATE_T], result: STRING },
+    "date.toDateString": { argTypes: [DATE_T], result: STRING },
+    "date.toTimeString": { argTypes: [DATE_T], result: STRING },
     /** The composed `new Date(dateString).getTime()` read: one borrowed
-     * string, f64 milliseconds since epoch. The parsed grammar is BOUNDED
-     * (documented divergence — V8's parser accepts far more): the ASN.1
-     * validity shape X509Certificate.validFrom/validTo answer ("Jul  1
-     * 00:00:00 2026 GMT" — the portless cert-expiry read), and ECMA's own
-     * date-time string format (YYYY-MM-DD[THH:mm[:ss[.sss]]][Z|±HH:MM] —
-     * date-only forms are UTC, exactly the spec). Anything else is NaN,
-     * Node's invalid-date getTime. Never throws. */
+     * string, f64 milliseconds since epoch, with V8's date-string grammar
+     * (the ES5 format, then the legacy forms: RFC 1123/2822, Date#toString,
+     * "Jan 2, 2024", ...). Zone-less dates are local time; anything V8
+     * rejects is NaN, Node's invalid-date getTime. Never throws. */
     "date.parseGetTime": { argTypes: [STRING], result: F64 },
     /** `Date.UTC(...)` — seven f64 arguments (the frontend completes the
      * spec's defaults for omitted trailing parts: month 0, date 1, time
@@ -3862,6 +4486,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * map to 1900+year, out-of-range months/dates roll over, non-finite
      * parts and out-of-range results answer NaN. Never throws. */
     "date.utc": { argTypes: [F64, F64, F64, F64, F64, F64, F64], result: F64 },
+    /** `new Date(year, monthIndex[, date, hours, minutes, seconds, ms])` —
+     * the same seven-f64 completion as date.utc, but the fields are LOCAL
+     * time: V8's MakeDay/MakeTime, then UTC(t) in the host zone (DST gaps
+     * read with the offset before the transition, overlaps answer the
+     * earlier instant), then TimeClip. Never throws. */
+    "date.newLocal": { argTypes: [F64, F64, F64, F64, F64, F64, F64], result: DATE_T },
     /** WHATWG TextDecoder.decode over u8 bytes (scr_bytes.c): utf-8 with
      * default options — the same maximal-subpart replacement decode as
      * Buffer.toString("utf8"), with the leading BOM stripped (the one