@scriptc/compiler 0.4.6 → 0.4.7

package/dist/ir/builtin-signatures.js

@@ -204,6 +204,8 @@ function buildLibFnSignatures() {
         "dyn.keyDelete": { argTypes: [DYN, STRING, BOOL], result: VOID },
         "dyn.keyDeleteComputed": { argTypes: [DYN, DYN, BOOL], result: VOID },
         "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 },
@@ -349,8 +351,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).
@@ -406,6 +422,13 @@ 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 },
         /** 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 +575,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 +588,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
@@ -755,17 +786,28 @@ 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 },
+        "os.userUid": { argTypes: [], result: F64 },
+        "os.userGid": { argTypes: [], result: F64 },
         "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 +994,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
@@ -1154,8 +1210,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
@@ -1256,6 +1325,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 +1478,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 +1491,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 },
@@ -1574,6 +1670,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 +1693,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,
@@ -2074,6 +2177,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": {
@@ -3422,6 +3527,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 +3736,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 +3747,33 @@ 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 },
+        /** 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 },
         "fs.callbackValue": { argTypes: [STRING], result: DYN },
         "fs.callbackCall": { argTypes: [STRING, DYN], result: DYN },
         "process.hrtimeValue": { argTypes: [], result: DYN },
@@ -3655,6 +3799,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 +3864,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;
@@ -3926,6 +4079,13 @@ function buildLibFnSignatures() {
         "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 +4169,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 },
@@ -4211,6 +4375,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 +4729,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 +4881,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
@@ -4824,6 +4995,12 @@ function buildLibFnSignatures() {
          * (key-order-witness.ts ordered spreads). Both are record types. Never
          * throws. */
         "record.sourceSpread": { argTypes: [null, null], 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 },
@@ -4848,11 +5025,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 +5259,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 +5427,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 +5516,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 +5530,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 },