@scriptc/compiler 0.3.6 → 0.4.1

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,21 @@ 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 },
+    /** for await over a checked-dynamic value: the loop's iterator (a
+     * compiled async generator, Symbol.asyncIterator's result, or the sync
+     * iterator), and whether that iterator is synchronous. */
+    "dyn.asyncIteratorOpen": { argTypes: [DYN, STRING], result: DYN },
+    "dyn.asyncIteratorWasSync": { argTypes: [], result: BOOL },
     "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 +200,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 +248,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 +268,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 +395,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
@@ -500,6 +603,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. */
@@ -509,6 +616,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. */
@@ -529,6 +642,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** realpath(3) with Node's error shape (syscall "lstat" in the message,
      * Node's own spelling for realpathSync failures). +1 fresh string. */
     "fs.realpathSync": { argTypes: [STRING], result: STRING },
+    /** fs.realpathSync (or its .native when the flag is true) as a function
+     * value: path and options arrive unchecked; the result is a string or a
+     * Buffer by the options' encoding. */
+    "fs.realpathValue": { argTypes: [DYN, DYN, BOOL], result: DYN },
     /** Native realpath with syscall "realpath" on failure. +1 fresh string. */
     "fs.realpathNativeSync": { argTypes: [STRING], result: STRING },
     /** The os.userInfo() field trio (uv_os_get_passwd's slices): pw_name,
@@ -593,6 +710,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 },
@@ -630,6 +748,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.
@@ -694,7 +819,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
@@ -805,6 +938,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 },
@@ -908,6 +1054,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "util.inherits": { argTypes: [DYN, DYN], result: VOID },
     "util.deprecate": { argTypes: [DYN, DYN, DYN, DYN], result: DYN },
     "util.callbackify": { argTypes: [DYN], result: DYN },
+    /** util.promisify over an untyped function value: a native dyn function
+     * whose calls answer a dyn promise the appended callback settles. */
+    "util.promisifyDyn": { 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 },
@@ -1058,10 +1207,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)
@@ -1122,6 +1294,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,
@@ -1164,6 +1343,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,
@@ -1210,6 +1398,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * 'error'. A synchronous throw INSIDE the lookup propagates out of the
      * connect call (may-throw seed). */
     "net.connectLookup": { argTypes: [F64, STRING, null], result: NETSOCKET_T },
+    /** connect({ host, port, lookup }) with a lookup of Node's own type, as
+     * a checked-dynamic function: the runtime calls it with { hints, all:
+     * true } and a callback taking an address string or list, then dials
+     * the answers in order. MAY THROW (host validation, a lookup throw). */
+    "net.connectLookupDyn": { argTypes: [F64, STRING, DYN], result: NETSOCKET_T },
     "net.sockWrite": { argTypes: [NETSOCKET_T, STRING], result: VOID },
     "net.sockWriteBytes": { argTypes: [NETSOCKET_T, BYTES_U8], result: VOID },
     "net.sockEnd": { argTypes: [NETSOCKET_T], result: VOID },
@@ -1280,10 +1473,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dgram.sendBytes": { argTypes: [DGRAMSOCK_T, BYTES_U8, F64, STRING], result: VOID },
     /** The send argument-validation ladder over dyn arguments (Node's
      * signature shuffle: slice bounds, list/type contracts, port/address
-     * validation, connected-state errors) — a fully-validated unconnected
-     * single-payload send RUNS; callback/list/connected forms meet the
-     * trailing fence. May-throw. */
-    "dgram.sendChk": { argTypes: [DGRAMSOCK_T, DYN, DYN, DYN, DYN, DYN, STRING], result: VOID },
+     * validation, connected-state errors), then the send: lists, connected
+     * sends and completion callbacks included. Up to six arguments, the
+     * missing ones undefined. May-throw. */
+    "dgram.sendChk": { argTypes: [DGRAMSOCK_T, DYN, DYN, DYN, DYN, DYN, DYN], result: VOID },
     "dgram.address": { argTypes: [DGRAMSOCK_T], result: VOID },
     "dgram.close": { argTypes: [DGRAMSOCK_T], result: VOID },
     "dgram.closeCb": {
@@ -1327,6 +1520,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 },
@@ -1357,11 +1557,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [STRING, F64, STRING, F64, STRING, F64, F64, F64],
         result: VOID,
     },
-    "test.suite": {
-        argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING, 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, F64, F64, F64],
         result: { kind: "promise", inner: VOID },
@@ -1375,6 +1574,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 },
@@ -1392,6 +1599,32 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "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
@@ -1669,15 +1902,21 @@ 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 },
-    /** https.request's servername option: the TLS name sent and verified.
-     * The "https." prefix keeps the TLS unit linked. */
-    "https.clientServername": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
+    /** 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. */
@@ -1707,6 +1946,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
@@ -1752,6 +2002,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,
@@ -1769,6 +2023,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 },
@@ -2143,11 +2405,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         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,
@@ -2161,6 +2425,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
             F64,
             F64,
             F64,
+            BOOL,
         ],
         result: STRING,
     },
@@ -2221,7 +2486,16 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "child.onSpawn": { argTypes: [CHILD_T, null], result: VOID },
     /** Rest listeners use the checked function bridge to pack event arguments. */
     "child.onDyn": { argTypes: [CHILD_T, STRING, DYN], result: VOID },
+    // Own properties JavaScript adds to children (handle-properties.ts).
+    "child.propsInstall": { argTypes: [], result: VOID },
+    "child.propsDefine": { argTypes: [DYN, DYN, DYN], result: DYN },
+    "child.propsDescriptor": { argTypes: [DYN, DYN], result: DYN },
+    "child.propsResolve": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "child.propsOnDyn": { 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 },
@@ -2230,8 +2504,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).
@@ -2344,8 +2619,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 },
@@ -2365,6 +2645,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 },
@@ -2412,6 +2725,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * cipher, key, iv and options arguments (scr_cipher.c): a native
      * Cipheriv/Decipheriv handle whose methods dispatch through dynInvoke. */
     "crypto.cipherNew": { argTypes: [BOOL, DYN, DYN, DYN, DYN], result: DYN },
+    /** createECDH(curveName) over a checked-dynamic curve (scr_ecdh.c): a
+     * native ECDH handle whose methods dispatch through dynInvoke. */
+    "crypto.ecdhNew": { argTypes: [DYN], result: DYN },
+    /** ECDH.convertKey(key, curve, inputEncoding, outputEncoding, format):
+     * the converted point as a Buffer or string. */
+    "crypto.ecdhConvertKey": { argTypes: [DYN, DYN, DYN, DYN, DYN], result: DYN },
     "crypto.hmacNewStr": { argTypes: [STRING, STRING], result: CRYPTOHMAC_T },
     "crypto.hmacNewBytes": { argTypes: [STRING, BYTES_U8], result: CRYPTOHMAC_T },
     "crypto.hashUpdateStr": { argTypes: [CRYPTOHASH_T, STRING], result: CRYPTOHASH_T },
@@ -2450,6 +2769,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 },
@@ -2462,6 +2786,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 },
@@ -2470,6 +2802,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
@@ -2481,6 +2832,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
@@ -2488,6 +2842,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
@@ -2495,6 +2850,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * allocUnsafeSlow never pool. The size forms validate like Node
      * (ERR_OUT_OF_RANGE). poolSize reads and writes Buffer.poolSize. */
     "buffer.alloc": { argTypes: [F64], result: BYTES_U8 },
+    /** Buffer.alloc as a function value: the size, fill and encoding arrive
+     * unchecked, and the runtime fills as Node's alloc does. */
+    "buffer.allocValue": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
     "buffer.allocUnsafe": { argTypes: [F64], result: BYTES_U8 },
     "buffer.allocUnsafeSlow": { argTypes: [F64], result: BYTES_U8 },
     "buffer.poolFromStr": { argTypes: [STRING, STRING], result: BYTES_U8 },
@@ -2502,18 +2860,23 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "buffer.poolFromBytes": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "buffer.poolFromArray": { argTypes: [arrayOf(F64)], result: BYTES_U8 },
     "buffer.poolFromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
+    /** poolFromDyn that also copies an array crossing by reference. */
+    "buffer.poolFromDynRef": { argTypes: [DYN, STRING], result: BYTES_U8 },
     "buffer.poolSize": { argTypes: [], result: F64 },
     "buffer.setPoolSize": { argTypes: [F64], result: VOID },
     /** Buffer.byteLength(string, enc) — enc a NORMALIZED literal like
      * fromStr's — and Buffer.isEncoding(name) over a runtime string
      * (case-insensitive against Node's alias set). Pure; never throw. */
     "buffer.byteLenDyn": { argTypes: [DYN, STRING], result: F64 },
+    /** Buffer.byteLength as a function value: the encoding arrives at run time. */
+    "buffer.byteLenValue": { argTypes: [DYN, DYN], result: F64 },
     "buffer.byteLenStr": { argTypes: [STRING, STRING], result: F64 },
     "buffer.isEncoding": { argTypes: [STRING], result: BOOL },
     /** Buffer.concat(list, totalLength): the concatenation truncated or
      * 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) —
@@ -2657,6 +3020,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 },
@@ -2784,6 +3150,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
@@ -2812,8 +3181,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 —
@@ -2905,6 +3279,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
@@ -2937,6 +3328,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
@@ -2995,6 +3409,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
@@ -3100,6 +3515,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 },
@@ -3151,6 +3567,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * `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 },
@@ -3164,6 +3587,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 },
@@ -3226,6 +3663,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
@@ -3252,6 +3691,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 },
@@ -3286,6 +3728,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 },
@@ -3312,7 +3758,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
@@ -3510,6 +3958,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 },
@@ -3681,18 +4130,28 @@ 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.errorHasCause": { argTypes: [null], result: BOOL },
+    "insp.errorBagHasProperties": { argTypes: [DYN], result: BOOL },
+    "insp.errorCause": { 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 },
@@ -3724,6 +4183,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.
@@ -3754,6 +4216,14 @@ 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 },
@@ -3761,6 +4231,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** 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,
@@ -3793,6 +4264,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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
@@ -3828,17 +4307,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
@@ -3934,6 +4429,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
@@ -3991,6 +4487,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 },
@@ -4008,14 +4507,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
@@ -4023,6 +4525,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
@@ -4033,6 +4541,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * 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 },
+    /** The Buffer brand of a Uint8Array source onto a fresh Uint8Array
+     * result (map and filter of a Buffer return a Buffer). */
+    "bytes.copyBrand": { argTypes: [BYTES_U8, BYTES_U8], result: VOID },
     "text.decodeBufferSource": { argTypes: [DYN], result: STRING },
     "text.decodeOptions": { argTypes: [BYTES_U8, BOOL, BOOL], result: STRING },
     "text.decodeStream": { argTypes: [DYN, BYTES_U8, F64, BOOL, BOOL, BOOL], result: STRING },