@scriptc/compiler 0.4.5 → 0.4.6

package/dist/ir/builtin-signatures.js

@@ -1,5 +1,5 @@
 import { BIGINT_T } from "./ir.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DIR_T, DGRAMSOCK_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REGEX, SEARCH_PARAMS_T, SECURECTX_T, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, URL_T, VOID, funcOf, } from "./ir.js";
+import { arrayOf, BIGINT_STATS_T, BOOL, BYTES_U8, bytesOf, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DIR_T, DGRAMSOCK_T, DYN, F64, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REGEX, SEARCH_PARAMS_T, SECURECTX_T, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, URL_T, VOID, funcOf, } from "./ir.js";
 /** Preserve the closed names while giving every entry the same slot type. */
 function defineLibFnSignatures(signatures) {
     return signatures;
@@ -109,10 +109,6 @@ function buildLibFnSignatures() {
         "fetch.responseJson": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
         "fetch.responseText": { argTypes: [DYN], result: { kind: "promise", inner: STRING } },
         "fetch.responseBytes": { argTypes: [DYN], result: { kind: "promise", inner: BYTES_U8 } },
-        "fetch.abortControllerNew": { argTypes: [], result: DYN },
-        "fetch.abortTimeout": { argTypes: [DYN], result: DYN },
-        "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
@@ -130,6 +126,66 @@ function buildLibFnSignatures() {
         "json.parseReviver": { argTypes: [STRING, DYN], result: DYN },
         "json.stringifyReplacer": { argTypes: [DYN, DYN, STRING], result: DYN },
         "json.stringifyValue": { argTypes: [DYN, DYN, DYN], result: DYN },
+        /** @scriptc/node calls into Node loaded into the program (scr_node_island.c):
+         * the calling module's path, the specifier, the export name and the
+         * boxed argument array, copied as JSON. callSync answers the result's
+         * JSON copy or throws the copied error; call answers a promise of it. */
+        "nodeIsland.callSync": { argTypes: [STRING, STRING, STRING, DYN], result: DYN },
+        "nodeIsland.call": {
+            argTypes: [STRING, STRING, STRING, DYN],
+            result: { kind: "promise", inner: DYN },
+        },
+        /** Node islands (scope-B NI-4, scr_node_island_handle.c): island values
+         * are dyn values (`foreign` lowers as dyn), objects are handle boxes
+         * whose identity is the V8 object's. require/import load an island
+         * module by its absolute (or `$ORIGIN/`) path; the rest are member reads,
+         * writes and calls on island values, argument lists as one dyn array.
+         * requireModule(specifier) of @scriptc/node lowers to require too. */
+        "nodeIsland.require": { argTypes: [STRING], result: DYN },
+        /** NI-7: a deferred island module (path, boot guards + interface snapshot). */
+        "nodeIsland.defer": { argTypes: [STRING, STRING], result: DYN },
+        "nodeIsland.import": { argTypes: [STRING], result: { kind: "promise", inner: DYN } },
+        "nodeIsland.get": { argTypes: [DYN, STRING], result: DYN },
+        "nodeIsland.getKey": { argTypes: [DYN, DYN], result: DYN },
+        "nodeIsland.set": { argTypes: [DYN, STRING, DYN], result: VOID },
+        "nodeIsland.setKey": { argTypes: [DYN, DYN, DYN], result: VOID },
+        "nodeIsland.invoke": { argTypes: [DYN, STRING, DYN], result: DYN },
+        "nodeIsland.apply": { argTypes: [DYN, DYN], result: DYN },
+        "nodeIsland.applyTo": { argTypes: [DYN, DYN, DYN], result: DYN },
+        "nodeIsland.construct": { argTypes: [DYN, DYN], result: DYN },
+        "nodeIsland.instanceof": { argTypes: [DYN, DYN], result: BOOL },
+        /** Array.isArray of a dyn value in a program with Node islands: island
+         * arrays answer true too. */
+        "nodeIsland.isArray": { argTypes: [DYN], result: BOOL },
+        /** NI-5: a class instance crossing into an island, with the builder of
+         * its class's method table (run once per class). Answers the value. */
+        "nodeIsland.classMethods": { argTypes: [DYN, DYN], result: DYN },
+        /** NI-5b: native classes extending island classes. subclass(base, name,
+         * ctor, fields, methods, getters, setters) makes the JavaScript class;
+         * superConstruct(box, args) is the native constructor's super(...);
+         * superMethod(base, this, name, args) is super.name(...); defineField
+         * defines an instance field; promisify is util.promisify in the island. */
+        "nodeIsland.subclass": { argTypes: [DYN, STRING, DYN, DYN, DYN, DYN, DYN], result: DYN },
+        "nodeIsland.superConstruct": { argTypes: [DYN, DYN], result: DYN },
+        "nodeIsland.superMethod": { argTypes: [DYN, DYN, STRING, DYN], result: DYN },
+        "nodeIsland.defineField": { argTypes: [DYN, STRING, DYN], result: VOID },
+        "nodeIsland.promisify": { argTypes: [DYN], result: DYN },
+        /** NI-6 shared modules: registers a module the program shares with its
+         * islands (real path, exports JSON, accessor); the TDZ sentinel an
+         * accessor answers; the method table and constructor helper of an
+         * exported class by its class value (either may be undefined; answers
+         * the class value). */
+        "nodeIsland.share": { argTypes: [STRING, STRING, DYN], result: VOID },
+        "nodeIsland.sharedTdz": { argTypes: [], result: DYN },
+        "nodeIsland.classMethodsOf": { argTypes: [DYN, DYN, DYN], result: DYN },
+        /** `v instanceof Error` (or a builtin Error subclass) for an island value. */
+        "nodeIsland.instanceofGlobal": { argTypes: [DYN, STRING], result: BOOL },
+        /** Whether a dyn value is an island handle (never loads Node). */
+        "nodeIsland.isHandle": { argTypes: [DYN], result: BOOL },
+        /** Island arrays of copied values as copies (a result, or an awaited
+         * promise's value). */
+        "nodeIsland.copyArrays": { argTypes: [DYN], result: DYN },
+        "nodeIsland.awaitCopy": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
         /** Keyed WRITE on a dyn value — `h.onDone = cb` / `h["k"] = v` on a
          * checked-dynamic object (args: receiver, key string, value — all
          * borrowed; the runtime copies the key and retains the value in). An
@@ -335,6 +391,18 @@ function buildLibFnSignatures() {
         "module.parent": { argTypes: [F64], result: F64 },
         "module.loaded": { argTypes: [F64], result: BOOL },
         "module.cacheGet": { argTypes: [STRING], result: F64 },
+        /** createRequire's require(id) and require.resolve(request, options)
+         * with a specifier computed at run time (scr_require.c): the arguments,
+         * then the requiring file, the call's "file:line" and the builtin ids.
+         * Both resolve like Node at run time. requireComputed always throws
+         * (Node's argument errors or MODULE_NOT_FOUND), or ends the program with
+         * an SC2020 refusal when the specifier resolves; resolveComputed answers
+         * the resolved id or real path. */
+        "module.requireComputed": { argTypes: [DYN, STRING, STRING, arrayOf(STRING)], result: DYN },
+        "module.resolveComputed": {
+            argTypes: [DYN, DYN, STRING, STRING, arrayOf(STRING)],
+            result: STRING,
+        },
         "module.cacheHas": { argTypes: [STRING], result: BOOL },
         "module.cacheKeys": { argTypes: [], result: arrayOf(STRING) },
         "timers.setTimeout": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: VOID },
@@ -530,6 +598,9 @@ function buildLibFnSignatures() {
         "fs.rmSync": { argTypes: [STRING], result: VOID },
         "fs.rmdirSync": { argTypes: [STRING], result: VOID },
         "fs.readdirSync": { argTypes: [STRING], result: arrayOf(STRING) },
+        /** `fs.readdirSync(path, { recursive: true })`: every entry below the
+         * path, relative to it, in Node's queue order. */
+        "fs.readdirRecursiveSync": { argTypes: [STRING], result: arrayOf(STRING) },
         // Result is the call site's Dirent record array (VOID is the
         // structure-checked sentinel, the os.networkInterfaces pattern).
         /** `fs.readdirSync(path, { withFileTypes: true })` — Dirent rows over
@@ -797,6 +868,7 @@ function buildLibFnSignatures() {
         // (subject, characters, NUL-separated replacement texts): the fused
         // chain of global one-character replacements.
         "str.replaceChars": { argTypes: [STRING, STRING, STRING], result: STRING },
+        "str.codePoints": { argTypes: [STRING], result: arrayOf(STRING) },
         /* ToNumber(string) — ECMA-262 7.1.4.1 StringToNumber (scr_string.c):
          * trim the JS StrWhiteSpace set, empty/whitespace-only → +0, then the
          * whole span must be one StrNumericLiteral — signed decimal (Infinity
@@ -1104,6 +1176,20 @@ function buildLibFnSignatures() {
         "util.inherits": { argTypes: [DYN, DYN], result: VOID },
         "util.inheritsPrototype": { argTypes: [DYN, DYN, DYN], result: VOID },
         "util.deprecate": { argTypes: [DYN, DYN, DYN, DYN], result: DYN },
+        "util.isArrayDeprecated": { argTypes: [DYN], result: BOOL },
+        "util.extend": { argTypes: [DYN, DYN], result: DYN },
+        "util.signalExitCode": { argTypes: [DYN], result: F64 },
+        "util.aborted": { argTypes: [DYN, DYN], result: DYN },
+        "util.diff": { argTypes: [DYN, DYN], result: DYN },
+        "util.debounce": { argTypes: [DYN, DYN, DYN], result: DYN },
+        "util.throttle": { argTypes: [DYN, DYN, DYN, DYN], result: DYN },
+        "webstream.class": { argTypes: [F64], result: DYN },
+        "webstream.instanceOf": { argTypes: [DYN, F64], result: BOOL },
+        "webstream.install": { argTypes: [], result: VOID },
+        "mime.typeNew": { argTypes: [DYN, DYN], result: DYN },
+        "mime.typeParse": { argTypes: [DYN], result: DYN },
+        "mime.paramsNew": { argTypes: [], result: DYN },
+        "mime.is": { argTypes: [DYN, F64], result: BOOL },
         "util.callbackify": { argTypes: [DYN], result: DYN },
         /** util.promisify over an untyped function value: a native dyn function
          * whose calls answer a dyn promise the appended callback settles. */
@@ -1245,6 +1331,39 @@ function buildLibFnSignatures() {
         "stats.mtime": { argTypes: [STATS_T], result: DATE_T },
         "stats.ctime": { argTypes: [STATS_T], result: DATE_T },
         "stats.birthtime": { argTypes: [STATS_T], result: DATE_T },
+        /** BigIntStats (statSync with `{ bigint: true }`): the same snapshot
+         * handle under Node's bigint member table — every number member of Stats
+         * (the integers, `*Ms` and the BigIntStats-only `*Ns`) answers `bigint`;
+         * only the four time members stay `Date`s. */
+        "bigstats.isFile": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.isDirectory": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.isSymbolicLink": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.isBlockDevice": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.isCharacterDevice": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.isFIFO": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.isSocket": { argTypes: [BIGINT_STATS_T], result: BOOL },
+        "bigstats.size": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.dev": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.ino": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.blocks": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.nlink": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.mode": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.uid": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.gid": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.rdev": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.blksize": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.atimeNs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.mtimeNs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.ctimeNs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.birthtimeNs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.atimeMs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.mtimeMs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.ctimeMs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.birthtimeMs": { argTypes: [BIGINT_STATS_T], result: BIGINT_T },
+        "bigstats.atime": { argTypes: [BIGINT_STATS_T], result: DATE_T },
+        "bigstats.mtime": { argTypes: [BIGINT_STATS_T], result: DATE_T },
+        "bigstats.ctime": { argTypes: [BIGINT_STATS_T], result: DATE_T },
+        "bigstats.birthtime": { argTypes: [BIGINT_STATS_T], result: DATE_T },
         // The wider sync fs slice (unlink/chmod/chown/copyfile and the
         // mode-carrying write/mkdir forms).
         /** The wider sync fs slice (scr_lib.c), all throwing catchably with
@@ -1476,6 +1595,15 @@ function buildLibFnSignatures() {
             argTypes: [F64, STRING, { kind: "func", params: [], ret: VOID }],
             result: NETSOCKET_T,
         },
+        /** net.connect/createConnection(path[, connectListener]) and the
+         * `path` option: a client of the Unix socket at `path`. With the flag
+         * (a positional string), Node's isPipeName applies first: a string that
+         * reads as a non-negative number is a localhost port. */
+        "net.connectPath": { argTypes: [STRING, BOOL], result: NETSOCKET_T },
+        "net.connectPathCb": {
+            argTypes: [STRING, BOOL, { kind: "func", params: [], ret: VOID }],
+            result: NETSOCKET_T,
+        },
         // The lookup's exact func shape is program data (its answer callback's
         // union/record types) — checked specially in the libCall case.
         /** connect({ port, host, autoSelectFamily: true, lookup }) — the
@@ -2695,6 +2823,14 @@ function buildLibFnSignatures() {
         "child.onExit": { argTypes: [CHILD_T, null], result: VOID },
         "child.onClose": { argTypes: [CHILD_T, null], result: VOID },
         "child.onError": { argTypes: [CHILD_T, null], result: VOID },
+        /** The remove-by-identity pairs (child.off/removeListener): the
+         * listener argument is the closure VALUE that was registered —
+         * BORROWED, compared by pointer and never retained (a value the
+         * registry does not hold removes nothing). */
+        "child.offSpawn": { argTypes: [CHILD_T, null], result: VOID },
+        "child.offExit": { argTypes: [CHILD_T, null], result: VOID },
+        "child.offClose": { argTypes: [CHILD_T, null], result: VOID },
+        "child.offError": { argTypes: [CHILD_T, null], result: VOID },
         // Like process.envGet, spawnRes.status's result type is program-dependent
         // (the interned `number | null` union) — the libCall case checks the arms.
         "spawnRes.status": { argTypes: [SPAWNRES_T], result: VOID },
@@ -2728,6 +2864,10 @@ function buildLibFnSignatures() {
          * the OS at exit. All receivers borrowed. */
         "child.pid": { argTypes: [CHILD_T], result: VOID },
         "child.exitCode": { argTypes: [CHILD_T], result: VOID },
+        // child.signalCode's result is the interned `string | null` union
+        // (the terminating signal's name, null while running, after a normal
+        // exit, and after a spawn failure) — the spawnRes.signal pattern.
+        "child.signalCode": { argTypes: [CHILD_T], result: VOID },
         // The close-override pair: the bound close's result func type and the
         // override's func argument are program-dependent (the callback union's
         // tags) — the slots pin the server receiver; the libCall case checks
@@ -2807,9 +2947,27 @@ function buildLibFnSignatures() {
             result: { kind: "object", className: "%Duplex" },
         },
         /** Whether pipeline() pumps a checked-dynamic first stage as an
-         * iterable (a string, or a value with an iterator method that is not a
-         * stream with pipe() and on()) instead of piping it as a stream. */
+         * iterable (a string, a value with an iterator method that is not a
+         * stream with pipe() and on(), a { readable, writable } pair, or a
+         * source function's result) instead of piping it as a stream. */
         "stream.dynIterableSource": { argTypes: [DYN], result: BOOL },
+        /** The value pipeline() pumps for a checked-dynamic first stage: a
+         * source function's result (the flag set), which must be iterable, else
+         * a { readable, writable } pair's readable side or the value itself. */
+        "stream.dynSourceValue": { argTypes: [DYN, BOOL], result: DYN },
+        /** An untyped pipeline function stage's result before the last stage,
+         * which must be async iterable: ERR_INVALID_RETURN_VALUE naming the
+         * stage ("transform[i]") otherwise. Answers the value (+1). */
+        "stream.dynTransformResult": { argTypes: [DYN, STRING], result: DYN },
+        /** A checked-dynamic pipeline() stage taken as a stream: a native stream
+         * (+1), or Duplex.from of a value that is not stream-like or a function
+         * (an iterable), which the pipeline uses without piping into it. Other
+         * values throw: Duplex.from's ERR_INVALID_ARG_TYPE, or the given
+         * not-supported message. */
+        "stream.unboxDynStage": {
+            argTypes: [DYN, STRING],
+            result: { kind: "object", className: "%Duplex" },
+        },
         /** The Transform a Cipheriv or Decipheriv reads and writes as a stream
          * (+1, created on first use and owned by the cipher). */
         "stream.handleStream": {
@@ -3427,6 +3585,8 @@ function buildLibFnSignatures() {
         "process.pid": { argTypes: [], result: F64 },
         "dyn.this": { argTypes: [], result: DYN },
         "dyn.generatorThis": { argTypes: [], result: DYN },
+        /** A sloppy-mode function's `this` from its receiver: the global object
+         * for undefined and null, else the receiver. Never throws. */
         "process.getuid": { argTypes: [], result: F64 },
         "process.getgid": { argTypes: [], result: F64 },
         /** geteuid(2) / getegid(2) / getgroups(2) (the effective gid appended
@@ -3465,6 +3625,11 @@ function buildLibFnSignatures() {
          * (scr_module_namespace_value): the module id, its sorted export names
          * and the compiled getter. One object per module. Never throws. */
         "module.namespaceValue": { argTypes: [STRING, arrayOf(STRING), DYN], result: DYN },
+        /** A module namespace as typed code sees it through a dynamic slot
+         * (scr_module_namespace_dyn_value): the module id, its sorted export
+         * 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 },
         "fs.callbackValue": { argTypes: [STRING], result: DYN },
         "fs.callbackCall": { argTypes: [STRING, DYN], result: DYN },
         "process.hrtimeValue": { argTypes: [], result: DYN },
@@ -3508,6 +3673,7 @@ function buildLibFnSignatures() {
          * Options retain cause presence; constructor calls borrow their args.
          * Message coercion may throw before the cause is installed. */
         "error.newOptions": { argTypes: [DYN, DYN], result: VOID },
+        "error.captureStackTrace": { argTypes: [DYN, STRING, BOOL], result: VOID },
         "error.ctorOptions": { argTypes: [null, DYN, DYN], result: VOID },
         /** Borrowed Error receiver. cause returns an owned dyn value (undefined
          * when absent); hasCause distinguishes absence from present undefined. */
@@ -3640,6 +3806,15 @@ function buildLibFnSignatures() {
         "console.dirDyn": { argTypes: [DYN, F64], result: STRING },
         /** A native reference to the global object; known names retain value fences. */
         "global.native": { argTypes: [arrayOf(STRING)], result: DYN },
+        /** Installs the program's builtin-global lookup (global-values.ts). */
+        "global.installValues": { 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). */
+        "navigator.object": { argTypes: [], result: DYN },
+        "navigator.language": { argTypes: [], result: STRING },
+        "navigator.languages": { argTypes: [], result: DYN },
+        "navigator.platform": { argTypes: [], result: STRING },
         // `X.name` through a class value: the arg is a program-dependent
         // classval (a null slot; the libCall case checks the kind).
         /** `X.name` through a class VALUE (scr_object.c): args[0] is a borrowed
@@ -3831,7 +4006,6 @@ function buildLibFnSignatures() {
         "dyn.objectPrototype": { argTypes: [], result: DYN },
         "dyn.errorPrototype": { argTypes: [], result: DYN },
         "dyn.inheritsErrorPrototype": { argTypes: [DYN], result: BOOL },
-        "dyn.errorCaptureStackTrace": { argTypes: [DYN], result: DYN },
         "dyn.errorCaptureStackTraceFunction": { argTypes: [], result: DYN },
         "dyn.functionApply": { argTypes: [], result: DYN },
         "dyn.builtinMethod": { argTypes: [STRING, STRING], result: DYN },
@@ -3903,6 +4077,12 @@ function buildLibFnSignatures() {
          * 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.declAdopt for every other checked cast of a dynamic value to a
+         * record or array (`value as T`): a shared source object or array
+         * becomes a live capsule of the value built from it. A node that is not
+         * plain data, or that the value holds twice, keeps its separate copy.
+         * Never throws: the conversion already succeeded. */
+        "dyn.adoptShared": { 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
@@ -3937,6 +4117,41 @@ function buildLibFnSignatures() {
         // The string keys `for...in` visits on an array (args[0], any element
         // type) after its indices. Borrowed; never throws.
         "array.namedKeys": { argTypes: [null], result: arrayOf(STRING) },
+        /** super(...) in a class declared `extends Array`: the instance, the
+         * arguments (an array of its element type, or the implicit constructor's
+         * dyn argument array) and whether the elements are dyn values. */
+        "array.subclassConstruct": { argTypes: [null, null, BOOL], result: VOID },
+        "array.subclassConstructDyn": { argTypes: [null, DYN, BOOL], result: VOID },
+        /** ArraySpeciesCreate over an Array method's plain result: the receiver
+         * (borrowed), the result (moved), the species constructor's length
+         * argument (-1: the result's length) and whether to set the length. The
+         * result has the second argument's type. */
+        "array.speciesAdopt": { argTypes: [null, null, F64, BOOL], result: VOID },
+        /** ArraySpeciesCreate ahead of a method that calls back into the program
+         * (map, filter, flatMap): the receiver (borrowed) and the species
+         * constructor's length argument. The result has the receiver's type: the
+         * instance, or the receiver itself when it is a plain array. */
+        "array.speciesCreate": { argTypes: [null, F64], result: VOID },
+        /** The method's plain result (moved) defined on the instance
+         * array.speciesCreate answered (borrowed), and whether to set the length.
+         * The result has the second argument's type. */
+        "array.speciesFinish": { argTypes: [null, null, BOOL], result: VOID },
+        /** Array.of / Array.from on a class declared `extends Array`: the class
+         * (its name, a literal), the plain result (moved) and the constructor's
+         * length argument (negative: no argument). */
+        "array.classConstructAdopt": { argTypes: [STRING, null, F64], result: VOID },
+        /** `value instanceof C` for a dyn value and a class that extends Array
+         * (its name, a literal). */
+        "array.dynIsClass": { argTypes: [DYN, STRING], result: BOOL },
+        // The value of the foreign element (SCR_ARR_FOREIGN) at args[1] of an
+        // array (args[0], any element type); callers test the element state
+        // first. Borrowed; never throws.
+        "array.foreign": { argTypes: [null, F64], result: DYN },
+        /** The checked conversion's TypeError for the foreign element at args[1]
+         * of an array (args[0]) read where a value described by args[2] is
+         * expected. ALWAYS THROWS; polymorphic result (the error.nodeThrow
+         * pattern). May-throw seed. */
+        "array.foreignThrow": { argTypes: [null, F64, STRING], result: VOID },
         // 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 },
@@ -4537,12 +4752,54 @@ function buildLibFnSignatures() {
         "insp.errorCause": { argTypes: [null, F64, F64], result: STRING },
         "insp.dyn": { argTypes: [DYN, F64, F64], result: STRING },
         "insp.dynS": { argTypes: [DYN, F64], result: STRING },
+        /** util.format over a dyn array of its arguments, and
+         * util.formatWithOptions(options, pack): the runtime formatter for format
+         * strings known at run time and spread arguments. */
+        "insp.format": { argTypes: [DYN], result: STRING },
+        /** insp.format over arguments that are all strings, numbers, booleans,
+         * null or undefined, without the checked-dynamic walk. */
+        "insp.formatPrimitives": { argTypes: [arrayOf(DYN)], result: STRING },
+        "insp.formatList": { argTypes: [arrayOf(DYN)], result: STRING },
+        "insp.formatWithOptions": { argTypes: [DYN, DYN], result: STRING },
+        /** util.inspect(value, options, depth, colors) with the call's argument
+         * count: the runtime reads the options and renders the checked-dynamic
+         * view. */
+        "insp.inspect": { argTypes: [DYN, DYN, DYN, DYN, F64], result: STRING },
+        /** A [util.inspect.custom] method's call: whether ctx.customInspect is
+         * set, its depth argument (the remaining depth at recursion r of depth
+         * d), its options object and util.inspect, then its result rendered: a
+         * string re-indented at the current level, or a checked-dynamic value
+         * (customIsSelf tests for the instance itself). customInspect sets the
+         * flag for the renders that follow and answers the previous value, and
+         * depthKind does the same for how an unbounded depth was given (0
+         * Infinity, 1 null, 2 undefined). */
+        "insp.customEnabled": { argTypes: [], result: BOOL },
+        /** Registers a class's compiled custom inspect function under its
+         * instances' typed-ref type key, for the checked-dynamic walk. */
+        "insp.registerCustom": { argTypes: [STRING, DYN], result: VOID },
+        "insp.customInspect": { argTypes: [BOOL], result: BOOL },
+        "insp.depthKind": { argTypes: [F64], result: F64 },
+        "insp.customDepth": { argTypes: [F64, F64], result: DYN },
+        "insp.customOptions": { argTypes: [F64], result: DYN },
+        "insp.inspectFunction": { argTypes: [], result: DYN },
+        "insp.customText": { argTypes: [STRING], result: STRING },
+        "insp.customIsSelf": { argTypes: [DYN, DYN], result: BOOL },
+        "insp.customResult": { argTypes: [DYN, F64, F64], result: STRING },
+        /** Around the method's call: the inspect and format calls it makes run
+         * in a fresh inspect context with the default options. begin answers the
+         * token end takes; end also discards what a call that threw left. */
+        "insp.customCallBegin": { argTypes: [], result: F64 },
+        "insp.customCallEnd": { argTypes: [F64], result: VOID },
+        /** Whether a runtime format string has a '%' before its last character. */
+        "insp.formatSpecifies": { argTypes: [STRING], result: BOOL },
+        "insp.formatSpecifiesDyn": { argTypes: [DYN], result: BOOL },
+        "insp.dynFormatS": { argTypes: [DYN, F64], result: STRING },
         /** util.format's %o over a checked-dynamic value: inspect with
          * showHidden. Kinds whose hidden entries have no rendering throw the
          * 'not supported yet' Error. */
         "insp.dynHidden": { argTypes: [DYN, F64], result: STRING },
         "insp.begin": { argTypes: [F64], result: VOID },
-        /** util.inspect's breakLength, compact (0 for false) and sorted for the
+        /** 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 },
         "insp.entry": { argTypes: [STRING, BOOL], result: VOID },
@@ -5056,10 +5313,16 @@ function buildLibFnSignatures() {
         "fs.mkdtempSync": { argTypes: [STRING], result: STRING },
         "fs.accessSync": { argTypes: [STRING, F64], result: VOID },
         "fs.readFdSync": { argTypes: [F64, STRING], result: STRING },
+        /** The writeFileSync(fd, data) form: a write(2) loop over the whole
+         * string at the descriptor's current offset, leaving the descriptor
+         * open (closeSync owns it). Errors carry the fd operation's errno
+         * shape ("EBADF: bad file descriptor, write"). */
+        "fs.writeFileSyncFd": { argTypes: [F64, STRING], result: VOID },
         "fs.readFdSyncBytes": { argTypes: [F64], result: BYTES_U8 },
         /** Validated isatty(3) probe. Stream property lowering maps false to
          * undefined; tty.isatty exposes the boolean result directly. */
         "process.isTTY": { argTypes: [F64], result: BOOL },
+        "process.isTTYValue": { argTypes: [DYN], result: BOOL },
         // 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
@@ -5115,10 +5378,12 @@ export function libFnSignatures() {
 /** The function-stage runs of a pipeline of `total` stages that a stream
  * 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. */
+ * PassThrough pipeline() answers, or 3, an untyped destination whose
+ * result may be pumped there): 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;
+    const dest = (flags >> 1) & 3;
+    let runs = dest === 1 || dest === 3 ? 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++;