@scriptc/compiler 0.4.6 → 0.4.8

package/dist/ir/builtin-signatures.js

@@ -45,6 +45,23 @@ function buildLibFnSignatures() {
         "event.handleEventReader": { argTypes: [DYN], result: VOID },
         "event.targetDispatch": { argTypes: [null, DYN, DYN], result: BOOL },
         "event.targetCall": { argTypes: [null, DYN, STRING, DYN], result: DYN },
+        /** events.getEventListeners over an EventTarget: the type's listeners
+         * in registration order, as a checked-dynamic array. The receiver is
+         * the target as a checked-dynamic value (a plain target, an
+         * AbortSignal, or a compiled subclass's capsule); `type` is the string
+         * name, or the checked-dynamic form, where a value that is not a string
+         * matches no type and the answer is empty. */
+        "event.targetListeners": { argTypes: [DYN, STRING], result: DYN },
+        "event.targetListenersDyn": { argTypes: [DYN, DYN], result: DYN },
+        /** events.listenerCount over an EventTarget: the type's listeners, 0
+         * for a type it has none of (the `_dyn` form answers 0 for a value that
+         * is not a string). */
+        "event.targetListenerCount": { argTypes: [DYN, STRING], result: F64 },
+        "event.targetListenerCountDyn": { argTypes: [DYN, DYN], result: F64 },
+        /** events.getMaxListeners and events.setMaxListeners over an
+         * EventTarget: the target's limit, and its assignment. */
+        "event.targetGetMax": { argTypes: [DYN], result: F64 },
+        "event.targetSetMax": { argTypes: [DYN, F64], result: VOID },
         "event.call": { argTypes: [null, STRING, DYN], result: DYN },
         "event.get": { argTypes: [null, STRING], result: DYN },
         "event.set": { argTypes: [null, STRING, DYN], result: VOID },
@@ -203,7 +220,14 @@ function buildLibFnSignatures() {
          * arguments; other receiver representations retain a runtime refusal. */
         "dyn.keyDelete": { argTypes: [DYN, STRING, BOOL], result: VOID },
         "dyn.keyDeleteComputed": { argTypes: [DYN, DYN, BOOL], result: VOID },
+        /** `delete` on a primitive base: ToPropertyKey of the key, then the
+         * ToObject wrapper's own properties (a String's indexes and `length`
+         * answer false in sloppy code and throw in strict code). Borrows both
+         * operands; answers the delete's value. */
+        "dyn.primitiveDelete": { argTypes: [DYN, DYN, BOOL], result: BOOL },
         "dyn.reflectDeleteProperty": { argTypes: [DYN, DYN], result: BOOL },
+        /** Reflect.has's target check: Node's TypeError for a primitive. */
+        "dyn.reflectHasTarget": { argTypes: [DYN], result: VOID },
         "dyn.hasKeyComputed": { argTypes: [DYN, DYN], result: BOOL },
         "dyn.hasOwnComputed": { argTypes: [DYN, DYN], result: BOOL },
         "dyn.propertyIsEnumerableComputed": { argTypes: [DYN, DYN], result: BOOL },
@@ -219,6 +243,11 @@ function buildLibFnSignatures() {
          * whose fallback handles every other value. The key is a literal. */
         "dyn.typedRefKeyIs": { argTypes: [DYN, STRING], result: BOOL },
         "dyn.classIs": { argTypes: [DYN, STRING], result: BOOL },
+        /** A generated class table's indexed dispatch: the receiver's class key
+         * folded to the case it selects, or -1 for a value that is not a capsule
+         * or whose key is shorter than four bytes. The table switches on it and
+         * keeps its exact key guards (frontend/lowering/class-dynamic-dispatch.ts). */
+        "dyn.classHash": { argTypes: [DYN], result: F64 },
         /** Destructuring pack over a dyn source — `const [a, b] = d`, a
          * destructured dyn callback param (args: the source and the STATIC
          * TypeError spelling, "" when the source has none — both borrowed;
@@ -349,8 +378,22 @@ function buildLibFnSignatures() {
          * the may-throw seed set. */
         "dyn.defineProps": { argTypes: [DYN, DYN], result: DYN },
         "dyn.defineProperty": { argTypes: [DYN, DYN, DYN], result: DYN },
+        /** dyn.defineProps / dyn.defineProperty / dyn.objCreateWithProperties
+         * for a descriptor (or a property-descriptor map) built by an expression
+         * instead of a plain object literal: ToPropertyDescriptor accepts any
+         * object and reads each field through [[HasProperty]] and [[Get]]. */
+        "dyn.definePropsShapes": { argTypes: [DYN, DYN], result: DYN },
+        "dyn.definePropertyShapes": { argTypes: [DYN, DYN, DYN], result: DYN },
+        "dyn.objCreateWithPropertiesShapes": { argTypes: [DYN, DYN], result: DYN },
         "dyn.getOwnPropertyDescriptor": { argTypes: [DYN, DYN], result: DYN },
         "dyn.arrayProtoCall": { argTypes: [DYN, STRING, DYN], result: DYN },
+        /** The same call through the array-like unit (JavaScript sources):
+         * Array.prototype's generic algorithms over a receiver that is not a
+         * native array, and the invoke unit's dispatch for everything else. */
+        "dyn.arrayLikeProtoCall": { argTypes: [DYN, STRING, DYN], result: DYN },
+        /** Number.prototype / Boolean.prototype as JavaScript values: the
+         * prototype object (dyn.builtinPrototype unit). */
+        "dyn.builtinPrototype": { argTypes: [STRING], result: DYN },
         /** Promise.all / Promise.allSettled / Promise.any over a spread
          * checked-dynamic array: the values, the settled-record array, or the
          * first fulfillment (AggregateError once every entry rejects).
@@ -363,6 +406,11 @@ function buildLibFnSignatures() {
          * 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 } },
+        /** `Promise.<s>.call(C, value)` in a JavaScript source (scr_js_
+         * promise_generic.c): the static's name, the `this` constructor and the
+         * one argument the algorithm takes. Answers the capability's promise as
+         * a checked-dynamic value (a foreign C may answer anything). */
+        "promise.genericStatic": { argTypes: [STRING, DYN, DYN], result: 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
@@ -406,6 +454,19 @@ function buildLibFnSignatures() {
         "module.cacheHas": { argTypes: [STRING], result: BOOL },
         "module.cacheKeys": { argTypes: [], result: arrayOf(STRING) },
         "timers.setTimeout": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: VOID },
+        /** A setTimeout/setInterval delay that is not a literal in [1, 2^31-1]:
+         * the delay unchanged, after the warning Node's Timeout constructor
+         * emits when it sets the delay to 1 (scr_timer_user_delay). The second
+         * argument is 0 for the global setTimeout, 1 for the global
+         * setInterval and 2 for a node:timers import, plus 4 for a delay read
+         * from an array element. */
+        "timers.userDelay": { argTypes: [F64, F64], result: F64 },
+        /** A timer callback that runs with `this` bound to its handle, as Node
+         * calls it with the Timeout or Immediate (scr_timer_this_callback). */
+        "timers.thisCallback": {
+            argTypes: [{ kind: "func", params: [], ret: VOID }],
+            result: { kind: "func", params: [], ret: VOID },
+        },
         /** The repeating timer pair. setInterval takes (callback, ms) like
          * setTimeout and RETURNS the f64 handle the fallback declarations
          * promise (ids start at 1, so truthiness narrowing works); the loop
@@ -552,6 +613,11 @@ function buildLibFnSignatures() {
          * alive. Invalid callbacks and uncatchable signals throw. */
         "process.onSignal": { argTypes: [STRING, DYN, BOOL], result: VOID },
         "process.offSignal": { argTypes: [STRING, DYN], result: VOID },
+        /** process.prependListener(<signal>, cb): the same listener in front of
+         * the signal's existing registrations (Node appends with `on`, so the
+         * two differ only in dispatch order). Never `once` — that is
+         * prependOnceListener, which has no lowering. */
+        "process.prependSignal": { argTypes: [STRING, DYN], result: VOID },
         /** The process 'exit' event — process.on/once/off("exit"). args: [cb,
          * once bool] / [cb]. Listeners run SYNCHRONOUSLY at termination
          * (normal exit, process.exit(), the uncaught/unhandled exit-1 paths)
@@ -560,6 +626,9 @@ function buildLibFnSignatures() {
          * picks the runtime adapter. Never throw. */
         "process.onExit": { argTypes: [null, BOOL], result: VOID },
         "process.offExit": { argTypes: [null], result: VOID },
+        /** process.prependListener("exit", cb): the same listener in front of
+         * the exit registry's existing entries. */
+        "process.prependExit": { argTypes: [null], result: VOID },
         /** process.stdin listener registration — stdin.on/once("data" | "end" |
          * "error", cb). args: [cb, once bool]. data callbacks: () => void or
          * (chunk: Uint8Array) => void; end: () => void; error: () => void or
@@ -573,6 +642,27 @@ function buildLibFnSignatures() {
         /** 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 },
+        /** process.stdin.on/once("readable", cb): the paused-mode event —
+         * input stays buffered for read(), and the listener (no parameters)
+         * runs on the next tick when input arrives while a read wanted more,
+         * and once at EOF. Like a 'data' listener it keeps the loop alive
+         * until EOF. Never throws. */
+        "stdin.onReadable": { argTypes: [{ kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
+        /** process.stdin.pause()/resume(): Node's flowing flag. Buffered
+         * input stops reaching 'data' listeners while paused and flows again
+         * on resume. */
+        "stdin.pause": { argTypes: [], result: VOID },
+        "stdin.resume": { argTypes: [], result: VOID },
+        /** process.stdin.isPaused() — true in paused mode, which a 'readable'
+         * listener pins. */
+        "stdin.isPaused": { argTypes: [], result: BOOL },
+        /** process.stdin.readableLength — bytes buffered for read(). */
+        "stdin.readableLength": { argTypes: [], result: F64 },
+        /** process.stdin.read([size]): args [all bool, size]. Readable#read's
+         * size coercion (parseInt, NaN reads everything held, non-positive
+         * reads nothing) and its ERR_OUT_OF_RANGE above 1 GiB; the result is
+         * the `Uint8Array | null` union (the emitter constructs it). */
+        "stdin.read": { argTypes: [BOOL, F64], 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
@@ -755,17 +845,35 @@ function buildLibFnSignatures() {
          * 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 },
+        // Builtin functions read as values: validateString under Node's argument
+        // name, and node:path's value adapters (scr_builtin_values.c).
+        "dyn.validateString": { argTypes: [DYN, STRING], result: STRING },
+        "dyn.validateStrings": { argTypes: [DYN, STRING], result: arrayOf(STRING) },
+        "path.resolveValue": { argTypes: [DYN, BOOL], result: STRING },
+        "path.parseValue": { argTypes: [DYN, BOOL], result: DYN },
+        "path.formatValue": { argTypes: [DYN, BOOL], result: DYN },
+        "path.toNamespacedValue": { argTypes: [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,
-         * pw_shell, pw_dir — the PASSWD homedir, not os.homedir's $HOME-first
-         * cascade (Node's own split). The frontend assembles the UserInfo
-         * record from these plus getuid/getgid. +1 fresh strings; a passwd
-         * lookup failure aborts (Node throws a system error there — no
-         * compiled program path reaches it for the running uid). */
+        /** The os.userInfo() fields (uv_os_get_passwd's slices of the passwd
+         * entry for the effective uid): pw_name, pw_shell, pw_dir — the PASSWD
+         * homedir, not os.homedir's $HOME-first cascade (Node's own split) —
+         * and pw_uid, pw_gid (-1 on Windows). The frontend assembles the
+         * UserInfo record from these. +1 fresh strings; a passwd lookup
+         * failure aborts (Node throws a system error there — no compiled
+         * program path reaches it for the running uid). */
         "os.userName": { argTypes: [], result: STRING },
         "os.userShell": { argTypes: [], result: STRING },
         "os.userHomedir": { argTypes: [], result: STRING },
+        /** The same three fields as Buffers (os.userInfo({ encoding: 'buffer' })). */
+        "os.userNameBuf": { argTypes: [], result: BYTES_U8 },
+        "os.userShellBuf": { argTypes: [], result: BYTES_U8 },
+        "os.userHomedirBuf": { argTypes: [], result: BYTES_U8 },
+        "os.userUid": { argTypes: [], result: F64 },
+        "os.userGid": { argTypes: [], result: F64 },
+        /** The single passwd lookup the field libCalls above read: one per
+         * userInfo() record instead of one per field. */
+        "os.userInfoBegin": { argTypes: [], result: VOID },
         "os.tmpdir": { argTypes: [], result: STRING },
         // Result is the call site's Dict<NetworkInterfaceInfo[]> record (VOID is
         // the dgram.address sentinel — the libCall case checks the structure).
@@ -952,6 +1060,20 @@ function buildLibFnSignatures() {
          * grouping every three integer digits, "∞"/"NaN" texts, and "-0" for
          * negative inputs rounding to zero. Result +1; never throws. */
         "intl.numFormatEnUs": { argTypes: [F64], result: STRING },
+        /** `x.toLocaleString()` at the default locale: the same ICU number
+         * engine V8 uses, over the full ICU data (scr_intl.c). Throws an Error
+         * when the ICU data file is missing. Result +1. */
+        "icu.numFormatDefault": { argTypes: [F64], result: STRING },
+        /** `process.config.variables.v8_enable_i18n_support`: the number 1, as
+         * Node (which bundles ICU) answers. Reading it selects the `icu`
+         * runtime feature, so the binary that reports ICU is the binary that
+         * carries it (scr_intl.c). */
+        "icu.i18nSupport": { argTypes: [], result: F64 },
+        /** `d.toLocaleString()` / `d.toLocaleTimeString()` at the default
+         * locale over `d`'s time value (scr_intl.c). Throws an Error when the
+         * ICU data file is missing. Result +1. */
+        "icu.dateLocaleString": { argTypes: [DATE_T], result: STRING },
+        "icu.dateLocaleTimeString": { argTypes: [DATE_T], result: STRING },
         /** ES Symbol values (scr_symbol.c — link-gated by moduleUsesSymbol).
          * sym.new: `Symbol(desc)` — a fresh runtime-unique identity (+1) whose
          * one arg is the description string (borrowed); sym.newAnon is the
@@ -970,6 +1092,9 @@ function buildLibFnSignatures() {
         "sym.keyFor": { argTypes: [SYMBOL_T], result: VOID },
         "sym.desc": { argTypes: [SYMBOL_T], result: VOID },
         "sym.toString": { argTypes: [SYMBOL_T], result: STRING },
+        /** Symbol.keyFor called through its function value: the key or
+         * undefined, or Node's TypeError for a value that is not a symbol. */
+        "sym.keyForDyn": { argTypes: [DYN], result: DYN },
         /** Engine-free arbitrary-precision bigint operations (scr_bigint.c).
          * parse accepts the ECMAScript BigInt string grammar; fromF64 accepts
          * finite integral Numbers. Arithmetic returns fresh immutable values.
@@ -1020,6 +1145,10 @@ function buildLibFnSignatures() {
         "url.canParseBase": { argTypes: [STRING, STRING], result: BOOL },
         "url.parse": { argTypes: [STRING], result: DYN },
         "url.parseBase": { argTypes: [STRING, STRING], result: DYN },
+        /** URL.revokeObjectURL(id): the id arrives already converted. A
+         * compiled program registers no blob URLs, so Node's registry lookup
+         * always misses and the call answers undefined. Never throws. */
+        "url.revokeObjectURL": { argTypes: [STRING], result: VOID },
         "url.protocol": { argTypes: [URL_T], result: STRING },
         "url.origin": { argTypes: [URL_T], result: STRING },
         "url.username": { argTypes: [URL_T], result: STRING },
@@ -1154,8 +1283,21 @@ function buildLibFnSignatures() {
          * All borrow; string results +1; escape and stringify throw URIError
          * [ERR_INVALID_URI] on a lone surrogate. */
         "qs.parse": { argTypes: [STRING, STRING, STRING, F64], result: VOID },
+        /** parse with a decodeURIComponent option: qs, sep, eq, maxKeys and
+         * the option's value (a function decodes; any other value means the
+         * default decoder). The result is the same dictionary as qs.parse's. */
+        "qs.parseCustom": { argTypes: [STRING, STRING, STRING, F64, DYN], result: VOID },
         "qs.stringify": { argTypes: [DYN, STRING, STRING], result: STRING },
+        /** stringify with an encodeURIComponent option's value. */
+        "qs.stringifyCustom": { argTypes: [DYN, STRING, STRING, DYN], result: STRING },
+        /** A sep/eq argument that may not be a string: (value, default, parse). */
+        "qs.separator": { argTypes: [DYN, STRING, BOOL], result: STRING },
+        /** unescapeBuffer(s, decodeSpaces) as a new Buffer. */
+        "qs.unescapeBuffer": { argTypes: [STRING, BOOL], result: BYTES_U8 },
         "qs.escape": { argTypes: [STRING], result: STRING },
+        /** escape of a value that may not be a string: String(value) for an
+         * object or null, value + "" otherwise (a symbol throws TypeError). */
+        "qs.escapeValue": { argTypes: [DYN], result: STRING },
         "qs.unescape": { argTypes: [STRING], result: STRING },
         /** node:util.parseArgs: one checked-dynamic config object in, one
          * checked-dynamic ParsedResults tree out. Statically typed member reads
@@ -1225,17 +1367,18 @@ function buildLibFnSignatures() {
         "fs.statfsSync": { argTypes: [DYN, DYN], result: DYN },
         "fs.readlinkSyncStr": { argTypes: [DYN, DYN], result: STRING },
         "fs.readlinkSyncBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
-        /** fs.openSync(path, flags) → the raw fd as f64; fs.readSync/fs.writeSync
-         * over Buffer windows perform sequential I/O when position is -1 and
-         * offset-preserving positioned I/O otherwise; fs.writeStrSync is the
-         * utf8 string twin; and fs.closeSync(fd) closes the descriptor. This is
-         * the fd slice behind spawn/log-processing forms.
+        /** fs.openSync(path, flags, mode) → the raw fd as f64; fs.readSync/
+         * fs.writeSync over Buffer windows perform sequential I/O when position
+         * is -1 and offset-preserving positioned I/O otherwise; fs.writeStrSync
+         * is the utf8 string twin; and fs.closeSync(fd) closes the descriptor.
+         * This is the fd slice behind spawn/log-processing forms.
          * flags is Node's string
          * grammar ("r", "w", "a" and the +/x variants; unknown flags throw
-         * Node's ERR_INVALID_ARG_VALUE TypeError text). All throw Node-shaped
-         * fs errors (openSync ENOENT/EACCES..., readSync EBADF/range errors,
-         * closeSync EBADF). */
-        "fs.openSync": { argTypes: [STRING, STRING], result: F64 },
+         * Node's ERR_INVALID_ARG_VALUE TypeError text), and mode is open(2)'s
+         * creation mode (Node's 0o666 default, ERR_OUT_OF_RANGE outside
+         * 0..0xFFFFFFFF). All throw Node-shaped fs errors (openSync
+         * ENOENT/EACCES..., readSync EBADF/range errors, closeSync EBADF). */
+        "fs.openSync": { argTypes: [STRING, STRING, F64], result: F64 },
         "fs.openNumericSync": { argTypes: [STRING, F64, F64], result: F64 },
         "fs.readSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
         "fs.readSyncDyn": { argTypes: [DYN, DYN, DYN, DYN, DYN], result: F64 },
@@ -1256,6 +1399,23 @@ function buildLibFnSignatures() {
         "fs.watch": { argTypes: [STRING], result: FSWATCHER_T },
         "fs.watchCb": { argTypes: [STRING, null], result: FSWATCHER_T },
         "watcher.close": { argTypes: [FSWATCHER_T], result: VOID },
+        // FSWatcher's EventEmitter surface: (receiver, event code, once|prepend
+        // flags, listener) for on/once/addListener/prependListener/
+        // prependOnceListener, and (receiver, event code, listener) for
+        // off/removeListener. The listener's func type is program-dependent;
+        // the null slot pins the arity and the receiver.
+        "watcher.on": { argTypes: [FSWATCHER_T, F64, F64, null], result: VOID },
+        "watcher.off": { argTypes: [FSWATCHER_T, F64, null], result: VOID },
+        /** fs.watchFile(path, interval, persistent, listener) → void
+         * (scr_watch_file.c — its own gated unit; moduleUsesFsWatchFile is the
+         * switch, and scr_watch_file_install() is emitted with it). One
+         * libuv-shaped stat poller per RESOLVED path, shared by every listener
+         * on it; the listener's (current, previous) Stats func type is
+         * program-dependent, so the slot pins the arity. Statement position
+         * only (Node returns a StatWatcher). fs.unwatchFile(path[, listener])
+         * takes a borrowed listener; the null slot is the absent one. */
+        "fs.watchFile": { argTypes: [STRING, F64, BOOL, null], result: VOID },
+        "fs.unwatchFile": { argTypes: [STRING, null], result: VOID },
         /** The composed `new crypto.X509Certificate(data).fingerprint` read
          * (scr_lib.c — no certificate handle exists): the SHA-1 of the DER,
          * uppercase colon-separated, over PEM or raw-DER Buffer input; other
@@ -1392,6 +1552,12 @@ function buildLibFnSignatures() {
          * clamped like ftruncateSync's) and closes it. */
         "fs.truncateSync": { argTypes: [STRING, F64], result: VOID },
         "fs.copyFileSync": { argTypes: [STRING, STRING], result: VOID },
+        /** copyFileSync(src, dest, mode): libuv's uv_fs_copyfile flag bits —
+         * COPYFILE_EXCL (1) fails on an existing destination, COPYFILE_FICLONE
+         * (2) requests a reflink and falls back to a copy, COPYFILE_FICLONE_FORCE
+         * (4) requires one. Out-of-range modes throw the RangeError Node throws
+         * ("mode is out of range: >= 0 && <= 7"). */
+        "fs.copyFileFlagsSync": { argTypes: [STRING, STRING, F64], result: VOID },
         /** renameSync is the direct two-path syscall wrapper. renameCb defers
          * the operation to the loop and fires a program-shaped Error | null
          * callback through a backend-emitted adapter. */
@@ -1399,6 +1565,10 @@ function buildLibFnSignatures() {
         // Callback type is program-dependent (zero params or Error | null).
         "fs.renameCb": { argTypes: [STRING, STRING, null], result: VOID },
         "fs.writeFileModeSync": { argTypes: [STRING, STRING, F64], result: VOID },
+        /** writeFileSync(path, data, { mode, flag }): the same open(2) write
+         * with the disposition flag — flag 1 is "wx" (O_EXCL: EEXIST when the
+         * path exists), 0 is "w" (the default truncate-or-create). */
+        "fs.writeFileFlagsSync": { argTypes: [STRING, STRING, F64, F64], result: VOID },
         "fs.mkdirModeSync": { argTypes: [STRING, F64], result: VOID },
         "fs.mkdirRecursiveModeSync": { argTypes: [STRING, F64], result: VOID },
         "atomics.wait": { argTypes: [bytesOf("i32"), F64, F64, F64], result: STRING },
@@ -1482,6 +1652,40 @@ function buildLibFnSignatures() {
             argTypes: [STRING, arrayOf(STRING), F64, STRING, STRING],
             result: SPAWNRES_T,
         },
+        /** spawnSync with the `cwd`, `input`, and `shell` options (the
+         * SCR_CHILD_CP_OPTIONS build of scr_child.c): the cp.spawnSyncOpts
+         * contract plus the child's working directory ("" = inherit), stdin
+         * input (has_input false leaves fd 0 to the stdio mode — an absent
+         * `input` option; "" pipes an empty stdin), and the shell form
+         * (the complete command line through /bin/sh -c — the compiler emits
+         * it with an empty args list only, since Node warns DEP0190 for
+         * separate shell arguments), exactly Node's reading of the members.
+         * Args (cmd, argv, timeout, killSignal, inMode, outMode, errMode,
+         * cwd, input, hasInput, shell). Never throws, like every spawnSync
+         * form. */
+        "cp.spawnSyncExt": {
+            argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64, STRING, STRING, BOOL, BOOL],
+            result: SPAWNRES_T,
+        },
+        /** cp.spawnSyncExt with the `env` option: the trailing [k,v,...] pairs
+         * replace the child's environment. */
+        "cp.spawnSyncExtEnv": {
+            argTypes: [
+                STRING,
+                arrayOf(STRING),
+                F64,
+                STRING,
+                F64,
+                F64,
+                F64,
+                STRING,
+                STRING,
+                BOOL,
+                BOOL,
+                arrayOf(STRING),
+            ],
+            result: SPAWNRES_T,
+        },
         // node:net (scr_net.c). Listener slots are program-dependent closures —
         // null slots, checked in the libCall case (the child.onExit precedent);
         // the zero-param callbacks pin the exact func type here. The trailing
@@ -1574,6 +1778,12 @@ function buildLibFnSignatures() {
             result: VOID,
         },
         "net.serverOnConnection": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
+        /** server.off(event, listener) / removeListener: [server, listener
+         * closure, list kind]. The kind selects the event's registry (1 error,
+         * 2 close, 3 listening, 4 connection/secureConnection, 5 timeout,
+         * 6 drop — the scr_net.h SCR_NET_OFF_* values); Node removes the most
+         * recently added matching listener. Never throws. */
+        "net.serverOff": { argTypes: [NETSERVER_T, null, F64], result: VOID },
         /** 'secureConnection' — the TLS server's deferred 'connection' list
          * (handshake-completion timing); on a server without deferred
          * connections (a plain net server) the registration never fires,
@@ -1591,6 +1801,7 @@ function buildLibFnSignatures() {
          * compiler-rendered fence — ALWAYS THROWS (the error.nodeThrow
          * polymorphic-result carve-out). May-throw seed. */
         "net.connectOptsChk": { argTypes: [DYN, STRING], result: VOID },
+        "net.listenPortDyn": { argTypes: [DYN, STRING], result: F64 },
         "net.connectCb": {
             argTypes: [F64, STRING, { kind: "func", params: [], ret: VOID }],
             result: NETSOCKET_T,
@@ -2045,6 +2256,11 @@ function buildLibFnSignatures() {
          * per-shape adapter — the tags are program data). */
         "http.serverOnConnect": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
         "http.clientOnUpgrade": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
+        /** server.on("clientError", (err, socket) => ...): a request the parser
+         * rejects, or a connection error, goes to the listeners instead of the
+         * default 400/413/431 answer, as in Node. (err, socket) and shorter
+         * prefixes (the libCall case checks). */
+        "http.serverOnClientError": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
         "http.reqSocket": { argTypes: [HTTPREQ_T], result: NETSOCKET_T },
         // reqH2Stream's program-interned Http2Stream | undefined result is
         // checked in the special libCall cases in validate.ts.
@@ -2074,6 +2290,8 @@ function buildLibFnSignatures() {
         "http.reqHttpVersionMajor": { argTypes: [HTTPREQ_T], result: F64 },
         "http.reqHttpVersionMinor": { argTypes: [HTTPREQ_T], result: F64 },
         "http.reqAborted": { argTypes: [HTTPREQ_T], result: BOOL },
+        "http.reqDestroyed": { argTypes: [HTTPREQ_T], result: BOOL },
+        "http.resDestroyed": { argTypes: [HTTPRES_T], result: BOOL },
         "http.reqComplete": { argTypes: [HTTPREQ_T], result: BOOL },
         "http.resDestroy": { argTypes: [HTTPRES_T], result: VOID },
         "http.resOnClose": {
@@ -2151,6 +2369,11 @@ function buildLibFnSignatures() {
         "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 },
+        /** options.protocol checked before the request is built: the declared
+         * scheme against the agent's (the calling module's when the options
+         * carry no Agent value). MAY THROW ERR_INVALID_PROTOCOL. */
+        "http.clientProtocolCheck": { argTypes: [DYN, BOOL], result: VOID },
+        "http.clientProtocolCheckAgent": { argTypes: [DYN, BOOL, 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. */
@@ -2195,6 +2418,13 @@ function buildLibFnSignatures() {
         "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 },
+        /** request/get with a URL and an options record: Node's
+         * `{...urlToHttpOptions(new URL(url)), ...options}` merge at run time,
+         * then the walk above. Args (url, options, autoEnd[, cb]). MAY THROW. */
+        "http.requestUrlDyn": { argTypes: [STRING, DYN, BOOL], result: HTTPCLIENTREQ_T },
+        "http.requestUrlDynCb": { argTypes: [STRING, DYN, BOOL, null], result: HTTPCLIENTREQ_T },
+        "https.requestUrlDyn": { argTypes: [STRING, DYN, BOOL], result: HTTPCLIENTREQ_T },
+        "https.requestUrlDynCb": { argTypes: [STRING, 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
@@ -2721,10 +2951,11 @@ function buildLibFnSignatures() {
             argTypes: [STRING, arrayOf(STRING), BOOL, STRING, BOOL, arrayOf(STRING), F64],
             result: SPAWNRES_T,
         },
-        /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawnp
-         * with per-slot ignore/inherit/pipe modes (and number output fds), the
-         * all-piped Node default, and the child registered with the event loop,
-         * which polls waitpid(WNOHANG) at quiescence like timers.
+        /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawn
+         * after the PATH search in the parent, with per-slot ignore/inherit/pipe
+         * modes (and number output fds), the all-piped Node default, and the
+         * child registered with the event loop, which polls waitpid(WNOHANG) at
+         * quiescence like timers.
          * NEVER throws: spawn failure defers to the "error" event, Node-exact
          * (the error message is Node's "spawn <cmd> <ERRNO-NAME>"; an "error"
          * event with no listener prints it and exits 1 like an EventEmitter).
@@ -2785,6 +3016,13 @@ function buildLibFnSignatures() {
          * 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 },
+        /** The same callback slice with the `cwd` option (the
+         * SCR_CHILD_CP_OPTIONS build): the child starts in cwd.
+         * (cmd, argv, callback, shell, cwd). */
+        "cp.execFileCwd": {
+            argTypes: [STRING, arrayOf(STRING), null, BOOL, STRING],
+            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).
@@ -3222,6 +3460,20 @@ function buildLibFnSignatures() {
         /** 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 },
+        /** A run-time Buffer encoding name, normalized the way the method's
+         * owner reads it. normalizeEncoding is Node's getEncodingOps (empty and
+         * unknown names throw ERR_UNKNOWN_ENCODING); normalizeEncodingEmptyUtf8
+         * is Node's normalizeEncoding (an empty name reads as utf8, unknown
+         * names throw); normalizeEncodingOrUtf8 is Buffer.byteLength's read (an
+         * unknown name counts as utf8, nothing throws). */
+        "buffer.normalizeEncoding": { argTypes: [STRING], result: STRING },
+        "buffer.normalizeEncodingEmptyUtf8": { argTypes: [STRING], result: STRING },
+        "buffer.normalizeEncodingOrUtf8": { argTypes: [STRING], result: STRING },
+        /** buf.write with an encoding name known only at run time: Node checks
+         * the offset and length BEFORE it reads the name, so the raw value goes
+         * to the runtime and the range errors win over an unknown name. */
+        "buffer.writeStrDyn": { argTypes: [BYTES_U8, STRING, STRING, F64], result: F64 },
+        "buffer.writeStrDynLen": { argTypes: [BYTES_U8, STRING, STRING, F64, F64], 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
@@ -3253,6 +3505,8 @@ function buildLibFnSignatures() {
         "buffer.installValue": { argTypes: [], result: VOID },
         "buffer.staticValue": { argTypes: [STRING], result: DYN },
         "buffer.prototypeMember": { argTypes: [DYN], result: DYN },
+        "buffer.prototypeObject": { argTypes: [], result: DYN },
+        "buffer.slowBuffer": { argTypes: [DYN], result: BYTES_U8 },
         /** fs._toUnixTimestamp(time) over a dyn value: numeric strings and
          * finite numbers coerce (negatives answer now/1000, Node's shape);
          * everything else throws Node's ERR_INVALID_ARG_TYPE. May-throw. */
@@ -3380,6 +3634,8 @@ function buildLibFnSignatures() {
          * receivers are borrowed. */
         /** Connects scr_brotli.c to the zlib engine (%main, before any module). */
         "zlib.brotliInstall": { argTypes: [], result: VOID },
+        /** Connects scr_zstd.c the same way. */
+        "zlib.zstdInstall": { argTypes: [], result: VOID },
         "zlib.streamNew": { argTypes: [F64, DYN], result: VOID },
         "zlib.streamBytesWritten": { argTypes: [null], result: F64 },
         /** `stream instanceof zlib.Gzip`: the borrowed stream and the class's
@@ -3422,6 +3678,17 @@ function buildLibFnSignatures() {
             argTypes: [STRING, STRING, F64],
             result: { kind: "promise", inner: VOID },
         },
+        /** fs.promises.writeFile(path, data, { mode, flag }) and
+         * fs.promises.copyFile(src, dest, mode): the settled-promise twins of
+         * fs.writeFileFlagsSync and fs.copyFileFlagsSync. */
+        "fsp.writeFileFlags": {
+            argTypes: [STRING, STRING, F64, F64],
+            result: { kind: "promise", inner: VOID },
+        },
+        "fsp.copyFileFlags": {
+            argTypes: [STRING, STRING, F64],
+            result: { kind: "promise", inner: VOID },
+        },
         "fsp.mkdir": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
         /** The fs/promises option/member tail the certs pipeline uses: mkdir's
          * literal { recursive?, mode? } options (the mkdirSync matrix behind
@@ -3620,6 +3887,7 @@ function buildLibFnSignatures() {
         "process.versions": { argTypes: [], result: DYN },
         "process.builtinId": { argTypes: [DYN, arrayOf(STRING)], result: STRING },
         "process.builtinModule": { argTypes: [STRING, DYN], result: DYN },
+        "process.builtinObject": { argTypes: [STRING, DYN, arrayOf(STRING)], result: DYN },
         "process.builtinUnsupported": { argTypes: [STRING, STRING], result: DYN },
         /** A module namespace object as a checked-dynamic value
          * (scr_module_namespace_value): the module id, its sorted export names
@@ -3630,6 +3898,47 @@ function buildLibFnSignatures() {
          * names, the compiled getter, and the Symbol.toStringTag key. Draws
          * Node's frozen null-prototype object, one per module. Never throws. */
         "module.namespaceDyn": { argTypes: [STRING, arrayOf(STRING), DYN, DYN], result: DYN },
+        /** A primitive wrapper object (scr_js_wrapper_new): the kind
+         * (0 String, 1 Number, 2 Boolean), the value it converts, and the three
+         * constructor values for the prototypes' `constructor`. */
+        "wrapper.new": { argTypes: [F64, DYN, DYN, DYN, DYN], result: DYN },
+        /** %Iterator.prototype% and %Iterator% (scr_js_iterator.c), `new
+         * Iterator()` (always the abstract-class TypeError), Iterator.from over
+         * a checked value, and OrdinaryHasInstance(%Iterator%, value). */
+        "iterator.prototype": { argTypes: [], result: DYN },
+        "iterator.constructor": { argTypes: [], result: DYN },
+        "iterator.construct": { argTypes: [], result: DYN },
+        "iterator.from": { argTypes: [DYN], result: DYN },
+        "iterator.instanceOf": { argTypes: [DYN], result: BOOL },
+        /** ToObject (scr_js_wrapper_to_object): a wrapper for a primitive, the
+         * value for an object, a fresh object for null/undefined; then the
+         * three constructor values. */
+        "wrapper.toObject": { argTypes: [DYN, DYN, DYN, DYN], result: DYN },
+        /** `value instanceof String/Number/Boolean` (scr_js_wrapper_instance_of):
+         * the kind's prototype on the value's chain. */
+        "wrapper.instanceOf": { argTypes: [DYN, F64], result: BOOL },
+        /** Object.prototype.toString with the [[PrimitiveValue]] brands
+         * (scr_js_wrapper_object_tag); dyn.objectTag otherwise. */
+        "wrapper.objectTag": { argTypes: [DYN], result: STRING },
+        /** util.types brands that read the slot (scr_js_wrapper_type_is). */
+        "wrapper.typeIs": { argTypes: [DYN, STRING], result: BOOL },
+        /** The value unchanged, or the not-supported Error when its own data
+         * graph holds a wrapper (scr_js_wrapper_guard; the string names the
+         * consumer). guardList checks each element. */
+        "wrapper.guard": { argTypes: [DYN, STRING], result: DYN },
+        "wrapper.guardList": { argTypes: [arrayOf(DYN), STRING], result: arrayOf(DYN) },
+        /** Whether a member value a call read as `name` is the builtin
+         * String.prototype method of that name (scr_js_wrapper_is_string_method),
+         * and the method's receiver, ToString of the value
+         * (scr_js_wrapper_this_string). */
+        "wrapper.isStringMethod": { argTypes: [DYN, STRING], result: BOOL },
+        "wrapper.thisString": { argTypes: [DYN, STRING], result: DYN },
+        /** Boolean.prototype as a value in a JavaScript source: the wrapper
+         * unit's Boolean prototype object (the one `new Boolean(v)` instances
+         * inherit from), so its valueOf/toString accept a primitive boolean or
+         * a Boolean wrapper receiver and throw Node's brand-check TypeError for
+         * a foreign one. `constructor` is the compiled Boolean constructor. */
+        "wrapper.booleanPrototype": { argTypes: [DYN], result: DYN },
         "fs.callbackValue": { argTypes: [STRING], result: DYN },
         "fs.callbackCall": { argTypes: [STRING, DYN], result: DYN },
         "process.hrtimeValue": { argTypes: [], result: DYN },
@@ -3655,6 +3964,14 @@ function buildLibFnSignatures() {
          * never throws. */
         "process.stdoutWrite": { argTypes: [STRING], result: BOOL },
         "process.stdio": { argTypes: [F64], result: DYN },
+        /** The same stream object, reached by the typed write-slot lowering
+         * (the write method as a value, its replacement, a patched program's
+         * typed writes): identical at run time, and the link switch for the
+         * SCR_STDIO_WRITE_SLOT build of the events unit. */
+        "process.stdioSlot": { argTypes: [F64], result: DYN },
+        /** process.stdout/stderr.write(chunk) with a run-time chunk: Node's
+         * Writable validation, then a synchronous write. */
+        "process.stdioWriteDyn": { argTypes: [F64, DYN], result: BOOL },
         "process.stderrWrite": { argTypes: [STRING], result: BOOL },
         // error.new's result and the receiver slots are builtin-error classes —
         // program-dependent object types, checked in the libCall case.
@@ -3712,9 +4029,10 @@ function buildLibFnSignatures() {
          * arms (ERR_INVALID_THIS receivers, ERR_MISSING_ARGS arity ladders,
          * the symbol-to-string TypeError): args are [error-kind f64 (the
          * SCR_ERR_* index: 0 Error, 1 TypeError, 2 RangeError), code (empty =
-         * no code slot), message]. ALWAYS THROWS catchably; the result type is
-         * the replaced expression's own (never materialized — the
-         * global.undefRead pattern). May-throw seed. */
+         * no code slot), message], and optionally a fourth string, the error's
+         * own `url` property (ir/validate.ts accepts it). ALWAYS THROWS
+         * catchably; the result type is the replaced expression's own (never
+         * materialized — the global.undefRead pattern). May-throw seed. */
         "error.nodeThrow": { argTypes: [F64, STRING, STRING], result: VOID },
         /** JS ToString over a dyn value WITH the object protocol (a user
          * toString/valueOf member is CALLED and its throw propagates;
@@ -3804,10 +4122,20 @@ function buildLibFnSignatures() {
         "console.clear": { argTypes: [], result: VOID },
         "console.table": { argTypes: [DYN, DYN], result: VOID },
         "console.dirDyn": { argTypes: [DYN, F64], result: STRING },
+        "console.dirHidden": { argTypes: [DYN, F64], result: STRING },
         /** A native reference to the global object; known names retain value fences. */
         "global.native": { argTypes: [arrayOf(STRING)], result: DYN },
+        /** Arms the runtime check for the Node globals the native runtime does not
+         * implement (host-globals.ts): the compiler's derived name table. */
+        "global.hostAbsent": { argTypes: [arrayOf(STRING)], result: VOID },
+        /** `key in globalThis`: the host-global check, then the global object's
+         * own presence answer (scr_global_host_absent.c). */
+        "dyn.globalHas": { argTypes: [STRING], result: BOOL },
         /** Installs the program's builtin-global lookup (global-values.ts). */
         "global.installValues": { argTypes: [DYN], result: VOID },
+        /** Installs the program's static-member lookup for builtin constructor
+         * values (builtin-statics.ts). */
+        "dyn.installBuiltinStatics": { argTypes: [DYN], result: VOID },
         /** The keys `for (key in globalThis)` visits, as a fresh object. */
         "global.forInObject": { argTypes: [], result: DYN },
         /** Node's navigator global (scr_node_builtin.c). */
@@ -3922,10 +4250,26 @@ function buildLibFnSignatures() {
         "sharedArrayBuffer.new": { argTypes: [DYN], result: DYN },
         "sharedArrayBuffer.is": { argTypes: [DYN], result: BOOL },
         "arrayBuffer.new": { argTypes: [DYN], result: DYN },
+        /** `new ArrayBuffer(len, { maxByteLength })` in a JavaScript source
+         * (t262-dc C2): the maxByteLength reserved up front, the visible length
+         * len. */
+        "arrayBuffer.newResizable": { argTypes: [DYN, DYN], result: DYN },
+        /** `new SharedArrayBuffer(len, { maxByteLength })`: the same, growable. */
+        "sharedArrayBuffer.newGrowable": { argTypes: [DYN, DYN], result: DYN },
+        /** The %main prologue call that arms scr_js_buffers's views registry
+         * (buffers.ts): never throws, never answers. */
+        "arrayBuffer.armMutable": { argTypes: [], result: VOID },
         "ffi.argument": { argTypes: [DYN, STRING], result: DYN },
         "ffi.memoryModule": { argTypes: [DYN], result: DYN },
         "intl.segmenterNew": { argTypes: [], result: DYN },
         "intl.segmenterRefusing": { argTypes: [STRING], result: DYN },
+        /** `new Intl.Segmenter(locale?, { granularity: "word" })`: ICU's UAX
+         * #29 word iterator (scr_intl.c over ICU), which the
+         * table-driven grapheme segmenter above cannot express. The argument is
+         * the negotiated language tag; the empty string selects the default
+         * locale (ICU's, resolved from the host environment like V8's). +1
+         * handle. */
+        "icu.segmenterWord": { argTypes: [STRING], result: DYN },
         "arrayBuffer.is": { argTypes: [DYN], result: BOOL },
         "arrayBuffer.isView": { argTypes: [DYN], result: BOOL },
         "arrayBuffer.byteLengthGetter": { argTypes: [], result: F64 },
@@ -4009,6 +4353,10 @@ function buildLibFnSignatures() {
         "dyn.errorCaptureStackTraceFunction": { argTypes: [], result: DYN },
         "dyn.functionApply": { argTypes: [], result: DYN },
         "dyn.builtinMethod": { argTypes: [STRING, STRING], result: DYN },
+        /** A standard library prototype object as a value (`Date.prototype` read
+         * in a JavaScript source), named by its constructor: the unit in
+         * scr_dyn_stdlib_prototype.c. */
+        "dyn.stdlibPrototype": { argTypes: [STRING], result: DYN },
         "dyn.classPrototype": { argTypes: [DYN, DYN], result: DYN },
         "dyn.classBasePrototype": { argTypes: [DYN], result: DYN },
         "dyn.classInherit": { argTypes: [DYN, DYN], result: DYN },
@@ -4053,6 +4401,13 @@ function buildLibFnSignatures() {
         "dyn.isExtensible": { argTypes: [DYN], result: BOOL },
         "dyn.seal": { argTypes: [DYN], result: DYN },
         "dyn.isSealed": { argTypes: [DYN], result: BOOL },
+        /** Object.isExtensible / Object.isSealed of a value whose kind is known
+         * only at runtime: a native handle or a promise has no modeled integrity
+         * state, so these refuse (SC2020) instead of answering like
+         * dyn.isExtensible/dyn.isSealed, which the static arms (a class
+         * instance's checked view, a typed function value) keep using. */
+        "dyn.isExtensibleQuery": { argTypes: [DYN], result: BOOL },
+        "dyn.isSealedQuery": { argTypes: [DYN], result: BOOL },
         "dyn.objValues": { argTypes: [DYN], result: DYN },
         /** Object.values as a native vector of checked values, for results the
          * program consumes directly (for-of, index reads, read-only methods). */
@@ -4211,6 +4566,9 @@ function buildLibFnSignatures() {
         "emitter.emit": { argTypes: [null, STRING], result: BOOL },
         "emitter.emitFlex": { argTypes: [null, STRING], result: BOOL },
         "emitter.emitAny": { argTypes: [null, STRING], result: BOOL },
+        /** emit('error', ...payload) with a non-Error payload: (recv, then the
+         * arguments boxed) — VARIADIC like emitFlex. */
+        "emitter.emitErrorValue": { argTypes: [null], result: BOOL },
         /** An untyped emit of an event with a fixed tuple: (recv, name, k, then
          * k checked-dynamic arguments as given, then the event's converted
          * tuple) — VARIADIC like emitter.emit. hasTyped answers whether a
@@ -4562,6 +4920,10 @@ function buildLibFnSignatures() {
         "writable.writeU": { argTypes: [null, null], result: BOOL },
         "writable.writeDyn": { argTypes: [null, DYN], result: BOOL },
         "writable.writeEnc": { argTypes: [null, F64, DYN], result: BOOL },
+        /** The error-first write form: (recv, mode, chunk, encoding, cb) where
+         * mode 0 is a bytes chunk, 1 a string, 2 a run-time chunk, and the
+         * callback takes the completion's error (Node's null on success). */
+        "writable.writeEcb": { argTypes: [null, F64, null, DYN, null], result: BOOL },
         "writable.end": { argTypes: [null, F64], result: VOID },
         "writable.cork": { argTypes: [null], result: VOID },
         "writable.uncork": { argTypes: [null], result: VOID },
@@ -4710,7 +5072,7 @@ function buildLibFnSignatures() {
          * message, code — the %error marker skipped) and deep-compare each
          * against the caught value's; a mismatch throws the deep-equal
          * AssertionError (scr_assert.c). MAY THROW by design. */
-        "assert.expectsErrDyn": { argTypes: [DYN, DYN, STRING, BOOL], result: VOID },
+        "assert.expectsErrDyn": { argTypes: [DYN, DYN, STRING, BOOL, BOOL], result: VOID },
         /** A validation function against the caught value (Node's expectedException). */
         "assert.throwsValidate": { argTypes: [DYN, DYN, STRING, STRING, BOOL], result: VOID },
         // assert.ifError's typed entries (always throw; unit args never
@@ -4799,9 +5161,27 @@ function buildLibFnSignatures() {
          * 'not supported yet' Error. */
         "insp.dynHidden": { argTypes: [DYN, F64], result: STRING },
         "insp.begin": { argTypes: [F64], result: VOID },
-        /** util.inspect's breakLength, compact (-1 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 },
+        /** util.inspect's breakLength, compact (-1 for false), sorted and
+         * maxArrayLength (Infinity for null) for the renders that follow; the
+         * call site restores 80, 3, false and 100 afterwards. */
+        "insp.layout": { argTypes: [F64, F64, BOOL, F64], result: VOID },
+        /** The render's maxArrayLength, which the array, Map and Set traversals
+         * read: the option applies at every nesting level. */
+        "insp.maxArrayLength": { argTypes: [], result: F64 },
+        /** ctx.maxStringLength for the renders that follow; answers the previous
+         * value so the call site can restore it. */
+        "insp.maxStringLength": { argTypes: [F64], result: F64 },
+        /** ctx.getters for the renders that follow: whether an accessor
+         * property's getter runs (0 the labels only, 1 every getter, 2 the
+         * getters without a setter, 3 the getters with one); answers the previous
+         * value so the call site can restore it. */
+        "insp.getters": { argTypes: [F64], result: F64 },
+        /** The current ctx.getters, which the interned per-type helpers read: the
+         * option is run-time state shared by every call site. */
+        "insp.gettersMode": { argTypes: [], result: F64 },
+        /** An invoked accessor property's value, by the result's kind:
+         * `[Label: <primitive>]` or `[Label] <object>`. */
+        "insp.accessorValue": { argTypes: [DYN, STRING, F64, F64], result: STRING },
         "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).
@@ -4824,6 +5204,27 @@ function buildLibFnSignatures() {
          * (key-order-witness.ts ordered spreads). Both are record types. Never
          * throws. */
         "record.sourceSpread": { argTypes: [null, null], result: VOID },
+        /** `record.sourceShare(built, value)`: the record `built`, of value's
+         * record type, keeps value's kept source too (record-links.ts compose
+         * helpers). Never throws. */
+        "record.sourceShare": { argTypes: [null, null], result: VOID },
+        /** `record.link(copy, source, pair)`: the copy a narrowing conversion
+         * just built links to its source record (IrModule.recordLinks; `pair`
+         * a numLit). Borrows both. Never throws. */
+        "record.link": { argTypes: [null, null, F64], result: VOID },
+        /** `record.linkIs(copy, pair)`: whether the record links to a source
+         * through the pair (a numLit). Never throws. */
+        "record.linkIs": { argTypes: [null, F64], result: BOOL },
+        /** `record.linkSource(copy, pair)`: the source a record links to
+         * through the pair, which the caller has tested (record.linkIs); its
+         * type is the pair's source type. Never throws. */
+        "record.linkSource": { argTypes: [null, F64], result: VOID },
+        /** `record.sourceNote(built, keys)`: the record a width spread just
+         * built keeps `keys` (the copy's own keys, in order; declared ones are
+         * placeholders) as its kept source when they hold an undeclared key or
+         * another order (scr_record_source_note). The first is a record type,
+         * the second dyn (borrowed). Never throws. */
+        "record.sourceNote": { argTypes: [null, DYN], result: VOID },
         "insp.key": { argTypes: [STRING], result: STRING },
         "insp.moreItems": { argTypes: [F64], result: STRING },
         "insp.end": { argTypes: [STRING, STRING, STRING, F64, BOOL, BOOL], result: STRING },
@@ -4833,6 +5234,8 @@ function buildLibFnSignatures() {
          * `prefix inner` re-indented at the caller's level (+1). */
         "insp.nestedBegin": { argTypes: [], result: VOID },
         "insp.nestedEnd": { argTypes: [STRING, STRING], result: STRING },
+        /** nestedEnd's restore alone: the caller's context returns. */
+        "insp.nestedRestore": { argTypes: [], result: VOID },
         /** Around a top-level render that an inspection refusal can end: mark
          * records the inspector's frame and nesting depth, unwind (in the
          * render's finally) closes what the render left open above it. */
@@ -4848,11 +5251,20 @@ function buildLibFnSignatures() {
          * packed NEW pending; end: (enc, pending) → the buffered partial's
          * flush (+1). Node-exact per encoding (oracle-pinned); none throws. */
         "strdec.write": { argTypes: [STRING, F64, BYTES_U8], result: STRING },
+        /** The checked-dynamic chunk forms (a stream "data" payload): a string
+         * passes through unchanged without touching the buffered state, an
+         * ArrayBufferView decodes, anything else throws ERR_INVALID_ARG_TYPE. */
+        "strdec.writeDyn": { argTypes: [STRING, F64, DYN], result: STRING },
+        "strdec.nextDyn": { argTypes: [STRING, F64, DYN], result: F64 },
         "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 },
+        /** The same for an encoding that may not be a string (scr_inspect.c):
+         * an object whose `length` is 3 to 9 matches by its string in lower
+         * case; other values throw ERR_UNKNOWN_ENCODING formatted with %s. */
+        "strdec.encodingValue": { 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.
@@ -5073,6 +5485,9 @@ function buildLibFnSignatures() {
          * non-function. */
         /** Uncaught exception handlers and monitors: [callback dyn, once, monitor]. */
         "process.onUncaughtException": { argTypes: [DYN, BOOL, BOOL], result: VOID },
+        /** Uncaught handlers registered in FRONT of the registry's existing
+         * entries: [callback dyn, monitor] (never `once`). */
+        "process.prependUncaughtException": { argTypes: [DYN, BOOL], result: VOID },
         "process.offUncaughtException": { argTypes: [DYN, BOOL], result: VOID },
         "process.onUnhandledRejection": { argTypes: [DYN, BOOL], result: VOID },
         "process.offUnhandledRejection": { argTypes: [DYN], result: VOID },
@@ -5238,6 +5653,10 @@ function buildLibFnSignatures() {
          * lone surrogate as U+FFFD). Borrowed arg; owned (+1) string; never throws. */
         "text.decode": { argTypes: [BYTES_U8], result: STRING },
         "bytes.bufferSource": { argTypes: [DYN], result: BYTES_U8 },
+        "text.decoderInput": { argTypes: [DYN, F64, DYN, BOOL], result: BYTES_U8 },
+        "text.decoderFlag": { argTypes: [DYN, STRING], result: BOOL },
+        "text.decodeStreamOption": { argTypes: [DYN], result: BOOL },
+        "text.decoderEncodingOptions": { argTypes: [DYN, DYN], result: F64 },
         /** Whether an error-first callback's Buffer result is absent: the zlib
          * and crypto callback adapters pass NULL after an error. Borrowed arg;
          * never throws. */
@@ -5323,6 +5742,10 @@ function buildLibFnSignatures() {
          * undefined; tty.isatty exposes the boolean result directly. */
         "process.isTTY": { argTypes: [F64], result: BOOL },
         "process.isTTYValue": { argTypes: [DYN], result: BOOL },
+        /** A promise that never settles (events.once of an event that cannot
+         * occur, e.g. 'drain' on a synchronous process stream). The result is
+         * events.once's own Promise<any[]> type. */
+        "events.pendingForever": { argTypes: [], result: { kind: "promise", inner: arrayOf(DYN) } },
         // Like process.envGet: the result is the module's interned
         // `number | undefined` union — checked by arms in the libCall case.
         /** Terminal width over an fd literal (1/2 — process.stdout/stderr
@@ -5333,6 +5756,10 @@ function buildLibFnSignatures() {
         "process.columns": { argTypes: [F64], result: VOID },
         /** Terminal height, with the same fd and optional-number contract. */
         "process.rows": { argTypes: [F64], result: VOID },
+        /** process.stdin.isRaw: the raw-mode flag of a TTY stdin as the
+         * module's interned `boolean | undefined` union (a pipe-backed stdin
+         * has no such flag — Node answers undefined there). Never throws. */
+        "process.stdinIsRaw": { argTypes: [], result: VOID },
         /** process.stdin.destroy(): a deliberate no-op (no stream machinery
          * exists to tear down; documented in SEMANTICS.md). */
         "process.stdinDestroy": { argTypes: [], result: VOID },