@scriptc/compiler 0.4.2 → 0.4.4

package/dist/ir/builtin-signatures.js

@@ -16,6 +16,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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.responseLight": { argTypes: [DYN], result: arrayOf(STRING) },
     "fetch.input": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
     "abort.controllerNew": { argTypes: [], result: DYN },
     /** EventTarget / Event / CustomEvent construction (scr_event_target.c):
@@ -112,6 +113,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fetch.abortNow": { argTypes: [DYN], result: DYN },
     "fetch.abortAny": { argTypes: [DYN], result: DYN },
     "fetch.streamNew": { argTypes: [DYN], result: DYN },
+    "fetch.transformNew": { argTypes: [], result: DYN },
     // Program-dependent iterable: typed arrays/bytes/string stay intact so
     // the native stream can pull lazily; checked-dynamic values are the
     // fallback. The libCall validator in validate.ts checks the closed set.
@@ -120,6 +122,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "fetch.streamFrom": { argTypes: [null], result: DYN },
     // The chunk/result record depends on ReadableStream<T>; validated by validate.ts.
     "fetch.readerRead": { argTypes: [DYN], result: VOID },
+    /** Readable.fromWeb (scr_stream_from_web.c): the stream, objectMode,
+     * highWaterMark (< 0: the mode's default) and encoding ("": none). */
+    "fetch.readableFromWeb": { argTypes: [DYN, BOOL, F64, STRING], result: VOID },
     "json.parse": { argTypes: [STRING], result: DYN },
     "json.parseReviver": { argTypes: [STRING, DYN], result: DYN },
     "json.stringifyReplacer": { argTypes: [DYN, DYN, STRING], result: DYN },
@@ -166,6 +171,7 @@ 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.mathFold": { argTypes: [DYN, BOOL, STRING], result: F64 },
     "dyn.destructureRest": { argTypes: [DYN, STRING], result: DYN },
     "dyn.arrayFromIterator": { argTypes: [DYN], result: DYN },
     "dyn.iterator": { argTypes: [DYN, STRING], result: DYN },
@@ -217,6 +223,28 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** Throws Node's TypeError for a class field initializer on a
      * non-extensible instance: the field name. */
     "class.throwNotExtensible": { argTypes: [STRING], result: VOID },
+    /** Object.freeze of a record whose shape is freezable (frozen-records.ts):
+     * sets the frozen bit in its rc word (scr_record_freeze). The receiver is
+     * any record type. */
+    "record.freeze": { argTypes: [null], result: VOID },
+    /** Whether a record is frozen: its rc word's frozen bit, set by
+     * record.freeze and dyn.freeze of a capsule. Emitted inline. The receiver
+     * is any record type. */
+    "record.isFrozen": { argTypes: [null], result: BOOL },
+    /** Throws Node's TypeError for a write to a frozen record: the key, the
+     * object's text in the message ("#<Object>") and the operation (0 assign,
+     * 1 add, 2 delete). */
+    "record.throwFrozen": { argTypes: [STRING, STRING, F64], result: VOID },
+    /** Object.freeze of an array (scr_arr_freeze): sets its frozen bit, which
+     * the write guards of IrModule.freezableArrays test, and isFrozen reads.
+     * The receiver is any array type. */
+    "array.freeze": { argTypes: [null], result: VOID },
+    "array.isFrozen": { argTypes: [null], result: BOOL },
+    /** Object.freeze, seal or preventExtensions of a Map or Set
+     * (scr_map_prevent_extensions), which only makes it not extensible: its
+     * entries stay writable. The receiver is any map or set type. */
+    "collection.preventExtensions": { argTypes: [null], result: VOID },
+    "collection.isExtensible": { argTypes: [null], result: BOOL },
     "dyn.nativeSetNew": { argTypes: [DYN], result: DYN },
     "dyn.nativeSetIs": { argTypes: [DYN], result: BOOL },
     "dyn.nativeMapIs": { argTypes: [DYN], result: BOOL },
@@ -927,6 +955,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "url.set": { argTypes: [URL_T, STRING, STRING], result: VOID },
     "url.setChecked": { argTypes: [URL_T, STRING, DYN], result: VOID },
     "url.fileURLToPathUrl": { argTypes: [URL_T], result: STRING },
+    /** fileURLToPathUrl as a value: the path string, or the error it would
+     * throw (fs.existsSync and fs.promises URL paths). Never throws. */
+    "url.fileURLToPathValue": { argTypes: [URL_T], result: DYN },
+    /** getValidatedPath's null-byte check on a string path, and
+     * readFileSync's encoding check: what Node validates before it converts
+     * a later URL path. (path, argument name) and (encoding). */
+    "fs.checkPath": { argTypes: [STRING, STRING], result: VOID },
+    "fs.checkReadEncoding": { argTypes: [STRING], result: VOID },
     "url.fileURLToPathChecked": { argTypes: [DYN], result: STRING },
     "url.fileURLToPathOptions": { argTypes: [DYN, DYN], result: STRING },
     /** node:url's legacy API (scr_url_legacy.c): parse(url, parseQueryString,
@@ -1267,6 +1303,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64],
         result: SPAWNRES_T,
     },
+    /** cp.spawnSyncOpts with the `env` option: the trailing [k,v,...]
+     * pairs replace the child's environment (recordToEnvPairs). */
+    "cp.spawnSyncEnv": {
+        argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64, arrayOf(STRING)],
+        result: SPAWNRES_T,
+    },
     /** cp.spawnSyncOpts with the stdio carried as a RUNTIME string —
      * "pipe" | "ignore" | "inherit", proven by the call site's TYPE (the
      * defaultRunner idiom `stdio: options?.stdio ?? "pipe"`); the runtime
@@ -1477,6 +1519,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     },
     "dgram.sendStr": { argTypes: [DGRAMSOCK_T, STRING, F64, STRING], result: VOID },
     "dgram.sendBytes": { argTypes: [DGRAMSOCK_T, BYTES_U8, F64, STRING], result: VOID },
+    /** Connected AF_UNIX datagram sockets for the hot-shots package shim
+     * (the unix-dgram addon's surface): fd or result >= 0, -errno on
+     * failure; send answers 1 when the socket would block. */
+    "dgram.unixSocket": { argTypes: [], result: F64 },
+    "dgram.unixConnect": { argTypes: [F64, STRING], result: F64 },
+    "dgram.unixSend": { argTypes: [F64, BYTES_U8], result: F64 },
+    "dgram.unixClose": { argTypes: [F64], result: F64 },
     /** The send argument-validation ladder over dyn arguments (Node's
      * signature shuffle: slice bounds, list/type contracts, port/address
      * validation, connected-state errors), then the send: lists, connected
@@ -1767,7 +1816,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * connection (+1, the same handle net.connect would give);
      * sockRemoteAddress answers `string | undefined` (NULL after the fd
      * closed, Node's destroyed-socket undefined; a dual-stack accept of an
-     * IPv4 peer reads "::ffff:a.b.c.d" like Node). reqResume/reqDestroy and
+     * IPv4 peer reads "::ffff:a.b.c.d" like Node). reqResume/reqPause/reqDestroy and
      * the req error/close listener slots complete the IncomingMessage
      * surface portless's client responses use; resDestroy/resOnClose and
      * resWriteHeadPairs ([k0,v0,k1,v1,...] — the env.pairs helper's flat
@@ -1834,6 +1883,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "http.reqPipeClient": { argTypes: [HTTPREQ_T, HTTPCLIENTREQ_T], result: VOID },
     "http.reqPipeSock": { argTypes: [HTTPREQ_T, NETSOCKET_T], result: VOID },
     "http.reqResume": { argTypes: [HTTPREQ_T], result: VOID },
+    "http.reqPause": { argTypes: [HTTPREQ_T], result: VOID },
     "http.reqDestroy": { argTypes: [HTTPREQ_T], result: VOID },
     "http.reqOnError": { argTypes: [HTTPREQ_T, null, BOOL], result: VOID },
     "http.reqOnClose": {
@@ -2769,6 +2819,19 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** getDiffieHellman(groupName) and createDiffieHellmanGroup(name): a
      * native DiffieHellmanGroup handle. */
     "crypto.dhGroupNew": { argTypes: [DYN], result: DYN },
+    /** checkPrimeSync(candidate, options) and generatePrimeSync(size,
+     * options) over checked-dynamic arguments (scr_dh.c): a boolean, and an
+     * ArrayBuffer or bigint, as checked-dynamic results. The Cb forms take
+     * the callback and whether its error parameter takes null for Node's
+     * undefined, and call it in a later macrotask; Node's argument errors
+     * throw (may-throw). */
+    "crypto.checkPrimeSync": { argTypes: [DYN, DYN], result: DYN },
+    /** getCipherInfo(nameOrNid, options) over checked-dynamic arguments
+     * (scr_cipher_info.c): the info object or undefined. */
+    "crypto.getCipherInfo": { argTypes: [DYN, DYN], result: DYN },
+    "crypto.checkPrimeCb": { argTypes: [DYN, DYN, DYN, BOOL], result: VOID },
+    "crypto.generatePrimeSync": { argTypes: [DYN, DYN], result: DYN },
+    "crypto.generatePrimeCb": { argTypes: [DYN, DYN, DYN, BOOL], result: VOID },
     "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 },
@@ -2910,6 +2973,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** poolFromDyn that also copies an array crossing by reference. */
     "buffer.poolFromDynRef": { argTypes: [DYN, STRING], result: BYTES_U8 },
     "buffer.poolFromDynOffset": { argTypes: [DYN, DYN], result: BYTES_U8 },
+    /** Buffer.from(value, byteOffset, length): an ArrayBuffer's range with
+     * Node's fromArrayBuffer checks; other values as poolFromDynOffset. */
+    "buffer.poolFromDynRange": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
     "buffer.poolSize": { argTypes: [], result: F64 },
     "buffer.setPoolSize": { argTypes: [F64], result: VOID },
     /** Buffer.byteLength(string, enc) — enc a NORMALIZED literal like
@@ -2944,6 +3010,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * always throws Node's ERR_INVALID_ARG_TYPE ("The \"string\" argument
      * must be of type string. Received ..."). Borrowed dyn; may-throw. */
     "buffer.newStringFail": { argTypes: [DYN], result: BYTES_U8 },
+    "buffer.deprecation": { argTypes: [], result: VOID },
+    "buffer.deprecationCount": { argTypes: [], result: VOID },
+    "buffer.constructor": { argTypes: [], result: DYN },
+    "buffer.installValue": { argTypes: [], result: VOID },
+    "buffer.staticValue": { argTypes: [STRING], result: DYN },
+    "buffer.prototypeMember": { argTypes: [DYN], result: DYN },
     /** 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. */
@@ -3088,6 +3160,18 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     // or an optional Error | null slot (same success shape as fs.rename).
     "process.stdoutWriteBytesCb": { argTypes: [BYTES_U8, STRING, null], result: BOOL },
     "process.stderrWriteBytesCb": { argTypes: [BYTES_U8, STRING, null], result: BOOL },
+    /** The value of a FULFILLED promise, read without a microtask turn (+1
+     * for references): the tuple form of Promise.all reads its entries this
+     * way once the combinator fulfills, each entry widened to Promise<void>
+     * and read at the type it was built with (program-dependent). */
+    "promise.fulfilledValue": { argTypes: [null], result: VOID },
+    /** Promise.all's tuple form as a value: the entries (each widened to
+     * Promise<void>) join the runtime combinator, and when it fulfills the
+     * function reads the fulfilled entries into the tuple inside that
+     * settlement, so the result settles on the combinator's turn; a
+     * rejection settles it the same way. The result is the tuple's promise
+     * (program-dependent). */
+    "promise.allTuple": { argTypes: [null, null], result: VOID },
     "fsp.readFile": { argTypes: [STRING, STRING], result: { kind: "promise", inner: STRING } },
     "fsp.writeFile": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
     /** fs.promises.writeFile(path, data, { mode }): the settled-promise
@@ -3351,6 +3435,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * throw-site fields, dynamic writes) or an Object.prototype member. */
     "error.hasKey": { argTypes: [null, STRING], result: BOOL },
     "error.hasCode": { argTypes: [null], result: BOOL },
+    /** Whether the error's own `name` or `message` (the key) is an accessor
+     * a reflective definition installed. Borrows both; never throws. */
+    "error.ownAccessor": { argTypes: [null, STRING], result: BOOL },
+    /** That accessor's getter called on the error (owned result), and its
+     * setter called with the value (V8's TypeError without one). Borrow
+     * their arguments; throw what the accessor throws. */
+    "error.accessorGet": { argTypes: [null, STRING], result: DYN },
+    "error.accessorSet": { argTypes: [null, STRING, DYN], result: VOID },
     "error.defineCause": { argTypes: [null, DYN], result: VOID },
     "error.deleteCause": { argTypes: [null], result: VOID },
     /** The compiler-resolved Node-parity throw for always-throwing lowered
@@ -3540,9 +3632,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "weakSet.is": { argTypes: [DYN], result: BOOL },
     "weakMap.new": { argTypes: [DYN], result: DYN },
     "weakSet.new": { argTypes: [DYN], result: DYN },
+    "finalizationRegistry.new": { argTypes: [DYN], result: DYN },
+    "finalizationRegistry.is": { argTypes: [DYN], result: BOOL },
     "dyn.fromEntries": { argTypes: [DYN], result: DYN },
     "bytes.constructor": { argTypes: [STRING], result: DYN },
-    "bytes.instanceOf": { argTypes: [DYN, DYN], result: BOOL },
+    "bytes.instanceOf": { argTypes: [DYN, DYN, STRING], result: BOOL },
     "bytes.construct": { argTypes: [DYN, DYN, STRING], result: DYN },
     /** The ambient receiver — JS `this` in a plain (non-method) function
      * body: the innermost binding the current firing/dispatch window
@@ -3664,6 +3758,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.assignPrototype": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.definePrototypeProps": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.bagGet": { argTypes: [DYN, STRING, DYN], result: DYN },
+    /** A class field's creation in its instance's property bag: adds the
+     * string key as a default data property when absent, answering false
+     * (nothing changed) when the bag needs the general defineProperty path. */
+    "dyn.bagCreateField": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.bagSet": { argTypes: [DYN, STRING, DYN, DYN], result: VOID },
     "dyn.objCreate": { argTypes: [DYN], result: DYN },
     // Names a compiled class's prototype object (args[0]) after the class
@@ -3671,6 +3769,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "dyn.nameClassPrototype": { argTypes: [DYN, STRING], result: VOID },
     "dyn.objCreateWithProperties": { argTypes: [DYN, DYN], result: DYN },
     "dyn.getPrototype": { argTypes: [DYN], result: DYN },
+    // dyn.getPrototype for walks that compare each prototype with a program
+    // class's prototype: native builtin values end the walk (null).
+    "dyn.getPrototypeForIdentity": { argTypes: [DYN], result: DYN },
     "dyn.setPrototype": { argTypes: [DYN, DYN], result: DYN },
     "dyn.getOwnPropertyNames": { argTypes: [DYN], result: DYN },
     "dyn.ownKeys": { argTypes: [DYN], result: DYN },
@@ -3696,6 +3797,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * call: always throws Node's TypeError [ERR_MISSING_ARGS] with Node's
      * own (verbatim, doubly-wrapped) message. */
     "dyn.structuredClone": { argTypes: [DYN, DYN], result: DYN },
+    /** The declaration-typed boundary's adoption (decl-projection.ts):
+     * `source` is the dynamic value a boundary cast just converted, and
+     * `capsule` a live capsule of the native value built from it. Every
+     * object or array of `source` that something else still references
+     * becomes, in place, a live capsule of the native value built from it.
+     * Throws the path TypeError, changing nothing, when a converted object
+     * is not plain data (a prototype, accessors, symbols, frozen state). */
+    "dyn.declAdopt": { argTypes: [DYN, DYN], result: VOID },
     "dyn.cloneMissing": { argTypes: [], result: DYN },
     /** structuredClone with a NON-EMPTY transfer array of static values:
      * nothing static is transferable, so the call always throws Node's
@@ -3733,6 +3842,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     // Whether the array (args[0]) still has the key (args[1]) from its
     // namedKeys list. Borrowed; never throws.
     "array.hasNamedKey": { argTypes: [null, STRING], result: BOOL },
+    // Whether an array (args[0], any element type) has properties besides its
+    // elements: noncanonical numeric keys, match metadata or named
+    // properties. Borrowed; never throws.
+    "array.hasProperties": { argTypes: [null], result: BOOL },
+    // The key of an element access whose index is undefined (the property
+    // named "undefined"; frontend/lowering/undefined-index.ts).
+    "array.undefinedKey": { argTypes: [], result: F64 },
     // node:events EventEmitter: receivers are emitter-hierarchy objects and
     // the chaining forms (on/off/removeAll/setMax) return the receiver's
     // own class — program-dependent object types, checked in the libCall
@@ -3878,6 +3994,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stream.setDestroy": { argTypes: [null, null], result: VOID },
     "stream.setTransform": { argTypes: [null, null], result: VOID },
     "stream.setFlush": { argTypes: [null, null], result: VOID },
+    "stream.setConstruct": { argTypes: [null, null], result: VOID },
+    "stream.replaceConstruct": { argTypes: [null, null], result: VOID },
+    "stream.setWritev": { argTypes: [null, null], result: VOID },
+    "stream.setWritevDefault": { argTypes: [null, null], result: VOID },
     /** The dyn-options twins (a checked-dynamic options record — the JS
      * lane's `super(options)` forwarding and `new Readable(dynVar)`): the
      * option walk runs at RUNTIME with Node's reading rules. newDyn:
@@ -3904,6 +4024,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "stream.pipeline": { argTypes: [F64], result: VOID },
     "stream.pipelineDyn": { argTypes: [F64], result: VOID },
     "stream.pipelineStages": { argTypes: [F64, F64, F64, F64, F64], result: VOID },
+    "stream.composeStages": { argTypes: [F64, F64, F64, F64, F64], result: VOID },
     "stream.pipelineStagesDyn": { argTypes: [F64, F64, F64, F64, F64], result: VOID },
     /** stream.compose(count, s1..sn): the Duplex over a pipeline of the
      * streams (+1). MAY THROW (ERR_INVALID_ARG_VALUE for a stream that is
@@ -3948,6 +4069,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
         argTypes: [F64, F64, F64, F64, F64],
         result: { kind: "promise", inner: VOID },
     },
+    /** sp.pipelineStages with the options argument: the same head, then
+     * end (a bool) and, with flags bit 6, the options' signal (dyn). */
+    "sp.pipelineStagesOpts": {
+        argTypes: [F64, F64, F64, F64, F64],
+        result: { kind: "promise", inner: VOID },
+    },
     /** node:stream/consumers — the promise consumers over the readable
      * machinery: (s) → a pending promise settled at the terminal point
      * with the accumulated result (sc.text: the utf8 decode, sc.json: the
@@ -4004,6 +4131,33 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     /** The objectMode option's sides (readable, writable), applied right
      * after construction; answers the receiver (+1, the chaining shape). */
     "stream.objectMode": { argTypes: [null, BOOL, BOOL], result: VOID },
+    "stream.decodeStrings": { argTypes: [null, BOOL], result: VOID },
+    /** Runtime decodeStrings and defaultEncoding option values, applied
+     * after construction (answers the receiver +1); the encoding was
+     * validated by stream.checkEncodingOption before construction. */
+    "stream.optionValues": { argTypes: [null, DYN, DYN], result: VOID },
+    "stream.checkEncodingOption": { argTypes: [DYN], result: VOID },
+    "stream.duplexFromGen": { argTypes: [null, null, null, null, null, null], result: VOID },
+    "stream.duplexFromDyn": { argTypes: [DYN], result: VOID },
+    /** Duplex.from over a lone Readable or Writable, or a { readable,
+     * writable } pair of streams (duplexify.js's _duplexify). */
+    "stream.duplexifyReadable": { argTypes: [null], result: VOID },
+    "stream.duplexifyWritable": { argTypes: [null], result: VOID },
+    "stream.duplexifyPair": { argTypes: [null, null], result: VOID },
+    /** Duplex.from(promise): the promise and its box helper. */
+    "stream.duplexFromPromise": { argTypes: [null, null], result: VOID },
+    /** Duplex.from(asyncFunction): the stage, its source helper and the
+     * promise's box helper. */
+    "stream.duplexFromAsyncFn": { argTypes: [null, null, null], result: VOID },
+    /** The same for a body that declares the options argument: then the
+     * AbortController's abort() and its signal. */
+    "stream.duplexFromGenSignal": {
+        argTypes: [null, null, null, null, null, null, null, DYN],
+        result: VOID,
+    },
+    "stream.duplexFromAsyncFnSignal": { argTypes: [null, null, null, null, DYN], result: VOID },
+    "writable.writeEncoding": { argTypes: [null, STRING], result: VOID },
+    "writable.setDefaultEncoding": { argTypes: [null, DYN], result: VOID },
     /** Whether a readable.nextChunkDyn step answered the end (the done
      * marker; an object-mode stream can yield undefined). */
     "stream.chunkDone": { argTypes: [DYN], result: BOOL },
@@ -4039,17 +4193,39 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * forEach nothing; reduce: [stream, fn, init, hasInit, options, kind]
      * with the payload kind (0 dyn, 1 number, 2 boolean, 3 string). The
      * promise-returning ones reject instead of throwing. */
-    "readable.opMap": { argTypes: [null, DYN, DYN], result: VOID },
-    "readable.opFilter": { argTypes: [null, DYN, DYN], result: VOID },
-    "readable.opFlatMap": { argTypes: [null, DYN, DYN], result: VOID },
+    "readable.opMap": { argTypes: [null, DYN, DYN, DYN], result: VOID },
+    "readable.opFilter": { argTypes: [null, DYN, DYN, DYN], result: VOID },
+    "readable.opFlatMap": { argTypes: [null, DYN, DYN, DYN], result: VOID },
+    /** flatMap whose callback returns a compiled generator: the helpers
+     * over its type follow (async: next, read, return, throw; sync: next,
+     * return, throw). */
+    "readable.opFlatMapAsyncGen": {
+        argTypes: [null, DYN, DYN, DYN, null, null, null, null],
+        result: VOID,
+    },
+    "readable.opFlatMapSyncGen": { argTypes: [null, DYN, DYN, DYN, null, null, null], result: VOID },
     "readable.opDrop": { argTypes: [null, DYN, DYN], result: VOID },
     "readable.opTake": { argTypes: [null, DYN, DYN], result: VOID },
     "readable.opToArray": { argTypes: [null, DYN], result: { kind: "promise", inner: DYN } },
-    "readable.opForEach": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "readable.opSome": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: BOOL } },
-    "readable.opEvery": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: BOOL } },
-    "readable.opFind": { argTypes: [null, DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "readable.opForEach": {
+        argTypes: [null, DYN, DYN, DYN],
+        result: { kind: "promise", inner: VOID },
+    },
+    "readable.opSome": { argTypes: [null, DYN, DYN, DYN], result: { kind: "promise", inner: BOOL } },
+    "readable.opEvery": { argTypes: [null, DYN, DYN, DYN], result: { kind: "promise", inner: BOOL } },
+    "readable.opFind": { argTypes: [null, DYN, DYN, DYN], result: { kind: "promise", inner: DYN } },
+    /** The map family's last argument is the callback's { signal } (or
+     * undefined). reduceSignal adds ac.abort() (a closure) and
+     * { signal: ac.signal } for a reducer that reads them. */
     "readable.opReduce": { argTypes: [null, DYN, DYN, BOOL, DYN, F64], result: VOID },
+    "readable.opReduceSignal": {
+        argTypes: [null, DYN, DYN, BOOL, DYN, F64, null, DYN],
+        result: VOID,
+    },
+    "readable.opSignalList": { argTypes: [DYN], result: DYN },
+    "readable.opSignalOpts": { argTypes: [DYN], result: DYN },
+    "readable.opSignalOf": { argTypes: [DYN], result: DYN },
+    "readable.opOnceOptions": { argTypes: [], result: DYN },
     "readable.resume": { argTypes: [null], result: VOID },
     "readable.isPaused": { argTypes: [null], result: BOOL },
     "readable.pipe": { argTypes: [null, null, BOOL], result: VOID },
@@ -4231,6 +4407,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "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 },
+    /** A u8 byte view in a union arm, element or field: a DataView, Buffer
+     * or Uint8Array by its own flags. */
+    "insp.bytes": { 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 },
@@ -4258,6 +4437,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
      * (inspect, Object.keys/values/entries) then answer through its live
      * checked view. The receiver is any such record type. Never throws. */
     "record.sourceHas": { argTypes: [null], result: BOOL },
+    /** `record.sourceSpread(built, value)`: the record a literal starting
+     * with `...value` just built keeps the order of value's kept source
+     * (key-order-witness.ts ordered spreads). Both are record types. Never
+     * throws. */
+    "record.sourceSpread": { argTypes: [null, null], 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 },
@@ -4548,6 +4732,20 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "als.exitRun": { argTypes: [F64, DYN, DYN], result: DYN },
     "als.enterWith": { argTypes: [F64, DYN], result: VOID },
     "als.disable": { argTypes: [F64], result: VOID },
+    /** new AsyncLocalStorage(options) (Node's object check throws; MAY
+     * THROW) and the store's name option (dyn; "" without one). */
+    "als.newOptions": { argTypes: [DYN], result: F64 },
+    "als.name": { argTypes: [F64], result: DYN },
+    /** A function bound to the active context: the completion callbacks of
+     * callback-style APIs (always false: an empty context leaves the
+     * callback unbound) and AsyncLocalStorage.bind (always true). The typed
+     * form answers its closure argument's type; the dyn form throws Node's
+     * ERR_INVALID_ARG_TYPE for a non-function when always (MAY THROW). */
+    "als.bindCallback": { argTypes: [null, BOOL], result: VOID },
+    "als.bindCallbackDyn": { argTypes: [DYN, BOOL], result: DYN },
+    /** AsyncLocalStorage.snapshot(): a dyn function (cb, ...args) that runs
+     * cb in the context active at the snapshot. */
+    "als.snapshot": { argTypes: [], result: DYN },
     /** Channel.bindStore/unbindStore/runStores (scr_dc.c): the
      * AsyncLocalStorage integration — set-semantics bindings per store,
      * runStores entering every bound store with transform(data) around the
@@ -4603,6 +4801,10 @@ 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 },
+    /** A Date object for a time value a local holds (date-values.ts): a
+     * lib-call argument passes the time value itself, and any other use
+     * creates the Date. */
+    "date.fromTime": { argTypes: [F64], result: DATE_T },
     /** 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. */
@@ -4655,6 +4857,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "crypto.generateKeyPairSync": { argTypes: [DYN, DYN], result: DYN },
     "crypto.generateKeyPairCb": { argTypes: [DYN, DYN, DYN], result: VOID },
     "crypto.signOneshot": { argTypes: [DYN, DYN, DYN], result: DYN },
+    "crypto.diffieHellman": { argTypes: [DYN, DYN], result: DYN },
     "crypto.verifyOneshot": { argTypes: [DYN, DYN, DYN, DYN], result: DYN },
     "crypto.createSign": { argTypes: [DYN], result: DYN },
     "crypto.createVerify": { argTypes: [DYN], result: DYN },
@@ -4675,6 +4878,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "text.decoderEncoding": { argTypes: [DYN], result: F64 },
     "text.decoderName": { argTypes: [F64], result: STRING },
     "text.encodeInto": { argTypes: [DYN, DYN], result: DYN },
+    /** `value instanceof TextDecoder` (true) or `TextEncoder` (false) on a
+     * checked-dynamic value: a codec record's handle box (scr_text_codec_dyn.c).
+     * Borrowed; never throws. */
+    "text.codecIs": { argTypes: [DYN, BOOL], result: BOOL },
     "buffer.isAscii": { argTypes: [DYN], result: BOOL },
     "buffer.isUtf8": { argTypes: [DYN], result: BOOL },
     "buffer.transcode": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
@@ -4752,10 +4959,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
     "string.raw": { argTypes: [arrayOf(STRING), arrayOf(STRING)], result: STRING },
 });
 /** The function-stage runs of a pipeline of `total` stages that a stream
- * follows (positions bit j: stage j is a function): each pumps its last
- * generator into that stream through one (next, read, return) triple. */
-export function pipelinePumpedRuns(total, positions) {
-    let runs = 0;
+ * follows (positions bit j: stage j is a function), and an async
+ * generator destination's run (flags bits 1-2 = 1, pumped into the
+ * PassThrough pipeline() answers): each pumps its last generator through
+ * one (next, read, return) triple. */
+export function pipelinePumpedRuns(total, positions, flags) {
+    let runs = ((flags >> 1) & 3) === 1 ? 1 : 0;
     for (let j = 0; j + 1 < total; j++) {
         if (Math.floor(positions / 2 ** j) % 2 === 1 && Math.floor(positions / 2 ** (j + 1)) % 2 === 0)
             runs++;