@scriptc/compiler 0.4.7 → 0.4.8

package/dist/ir/builtin-signatures.js

@@ -45,6 +45,23 @@ function buildLibFnSignatures() {
         "event.handleEventReader": { argTypes: [DYN], result: VOID },
         "event.targetDispatch": { argTypes: [null, DYN, DYN], result: BOOL },
         "event.targetCall": { argTypes: [null, DYN, STRING, DYN], result: DYN },
+        /** events.getEventListeners over an EventTarget: the type's listeners
+         * in registration order, as a checked-dynamic array. The receiver is
+         * the target as a checked-dynamic value (a plain target, an
+         * AbortSignal, or a compiled subclass's capsule); `type` is the string
+         * name, or the checked-dynamic form, where a value that is not a string
+         * matches no type and the answer is empty. */
+        "event.targetListeners": { argTypes: [DYN, STRING], result: DYN },
+        "event.targetListenersDyn": { argTypes: [DYN, DYN], result: DYN },
+        /** events.listenerCount over an EventTarget: the type's listeners, 0
+         * for a type it has none of (the `_dyn` form answers 0 for a value that
+         * is not a string). */
+        "event.targetListenerCount": { argTypes: [DYN, STRING], result: F64 },
+        "event.targetListenerCountDyn": { argTypes: [DYN, DYN], result: F64 },
+        /** events.getMaxListeners and events.setMaxListeners over an
+         * EventTarget: the target's limit, and its assignment. */
+        "event.targetGetMax": { argTypes: [DYN], result: F64 },
+        "event.targetSetMax": { argTypes: [DYN, F64], result: VOID },
         "event.call": { argTypes: [null, STRING, DYN], result: DYN },
         "event.get": { argTypes: [null, STRING], result: DYN },
         "event.set": { argTypes: [null, STRING, DYN], result: VOID },
@@ -203,6 +220,11 @@ function buildLibFnSignatures() {
          * arguments; other receiver representations retain a runtime refusal. */
         "dyn.keyDelete": { argTypes: [DYN, STRING, BOOL], result: VOID },
         "dyn.keyDeleteComputed": { argTypes: [DYN, DYN, BOOL], result: VOID },
+        /** `delete` on a primitive base: ToPropertyKey of the key, then the
+         * ToObject wrapper's own properties (a String's indexes and `length`
+         * answer false in sloppy code and throw in strict code). Borrows both
+         * operands; answers the delete's value. */
+        "dyn.primitiveDelete": { argTypes: [DYN, DYN, BOOL], result: BOOL },
         "dyn.reflectDeleteProperty": { argTypes: [DYN, DYN], result: BOOL },
         /** Reflect.has's target check: Node's TypeError for a primitive. */
         "dyn.reflectHasTarget": { argTypes: [DYN], result: VOID },
@@ -221,6 +243,11 @@ function buildLibFnSignatures() {
          * whose fallback handles every other value. The key is a literal. */
         "dyn.typedRefKeyIs": { argTypes: [DYN, STRING], result: BOOL },
         "dyn.classIs": { argTypes: [DYN, STRING], result: BOOL },
+        /** A generated class table's indexed dispatch: the receiver's class key
+         * folded to the case it selects, or -1 for a value that is not a capsule
+         * or whose key is shorter than four bytes. The table switches on it and
+         * keeps its exact key guards (frontend/lowering/class-dynamic-dispatch.ts). */
+        "dyn.classHash": { argTypes: [DYN], result: F64 },
         /** Destructuring pack over a dyn source — `const [a, b] = d`, a
          * destructured dyn callback param (args: the source and the STATIC
          * TypeError spelling, "" when the source has none — both borrowed;
@@ -379,6 +406,11 @@ function buildLibFnSignatures() {
          * a promise that adopts a thenable's settlement, or a promise fulfilled
          * with the value. The second argument reads `then` as above. */
         "dyn.promiseResolve": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+        /** `Promise.<s>.call(C, value)` in a JavaScript source (scr_js_
+         * promise_generic.c): the static's name, the `this` constructor and the
+         * one argument the algorithm takes. Answers the capability's promise as
+         * a checked-dynamic value (a foreign C may answer anything). */
+        "promise.genericStatic": { argTypes: [STRING, DYN, DYN], result: DYN },
         /** Bare `typeof v` on a dyn value AS A STRING (arg: the dyn value,
          * borrowed; result: an owned string) — the dyn kind's JS answer:
          * undefined→"undefined", null/object/array/bytes→"object" (JS's oldest
@@ -429,6 +461,12 @@ function buildLibFnSignatures() {
          * setInterval and 2 for a node:timers import, plus 4 for a delay read
          * from an array element. */
         "timers.userDelay": { argTypes: [F64, F64], result: F64 },
+        /** A timer callback that runs with `this` bound to its handle, as Node
+         * calls it with the Timeout or Immediate (scr_timer_this_callback). */
+        "timers.thisCallback": {
+            argTypes: [{ kind: "func", params: [], ret: VOID }],
+            result: { kind: "func", params: [], ret: VOID },
+        },
         /** The repeating timer pair. setInterval takes (callback, ms) like
          * setTimeout and RETURNS the f64 handle the fallback declarations
          * promise (ids start at 1, so truthiness narrowing works); the loop
@@ -604,6 +642,27 @@ function buildLibFnSignatures() {
         /** process.stdin.on/once('keypress', cb) (scr_readline_tty.c): cb is the
          * listener as a checked-dynamic function, called with (str, key). */
         "stdin.onKeypress": { argTypes: [DYN, BOOL], result: VOID },
+        /** process.stdin.on/once("readable", cb): the paused-mode event —
+         * input stays buffered for read(), and the listener (no parameters)
+         * runs on the next tick when input arrives while a read wanted more,
+         * and once at EOF. Like a 'data' listener it keeps the loop alive
+         * until EOF. Never throws. */
+        "stdin.onReadable": { argTypes: [{ kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
+        /** process.stdin.pause()/resume(): Node's flowing flag. Buffered
+         * input stops reaching 'data' listeners while paused and flows again
+         * on resume. */
+        "stdin.pause": { argTypes: [], result: VOID },
+        "stdin.resume": { argTypes: [], result: VOID },
+        /** process.stdin.isPaused() — true in paused mode, which a 'readable'
+         * listener pins. */
+        "stdin.isPaused": { argTypes: [], result: BOOL },
+        /** process.stdin.readableLength — bytes buffered for read(). */
+        "stdin.readableLength": { argTypes: [], result: F64 },
+        /** process.stdin.read([size]): args [all bool, size]. Readable#read's
+         * size coercion (parseInt, NaN reads everything held, non-positive
+         * reads nothing) and its ERR_OUT_OF_RANGE above 1 GiB; the result is
+         * the `Uint8Array | null` union (the emitter constructs it). */
+        "stdin.read": { argTypes: [BOOL, F64], result: VOID },
         /** The for-await chunk source over process.stdin: no args, result
          * Promise<Uint8Array> (+1). Fulfills with the next arrived chunk; the
          * EMPTY bytes value is the done sentinel (POSIX reads never deliver
@@ -806,8 +865,15 @@ function buildLibFnSignatures() {
         "os.userName": { argTypes: [], result: STRING },
         "os.userShell": { argTypes: [], result: STRING },
         "os.userHomedir": { argTypes: [], result: STRING },
+        /** The same three fields as Buffers (os.userInfo({ encoding: 'buffer' })). */
+        "os.userNameBuf": { argTypes: [], result: BYTES_U8 },
+        "os.userShellBuf": { argTypes: [], result: BYTES_U8 },
+        "os.userHomedirBuf": { argTypes: [], result: BYTES_U8 },
         "os.userUid": { argTypes: [], result: F64 },
         "os.userGid": { argTypes: [], result: F64 },
+        /** The single passwd lookup the field libCalls above read: one per
+         * userInfo() record instead of one per field. */
+        "os.userInfoBegin": { argTypes: [], result: VOID },
         "os.tmpdir": { argTypes: [], result: STRING },
         // Result is the call site's Dict<NetworkInterfaceInfo[]> record (VOID is
         // the dgram.address sentinel — the libCall case checks the structure).
@@ -1026,6 +1092,9 @@ function buildLibFnSignatures() {
         "sym.keyFor": { argTypes: [SYMBOL_T], result: VOID },
         "sym.desc": { argTypes: [SYMBOL_T], result: VOID },
         "sym.toString": { argTypes: [SYMBOL_T], result: STRING },
+        /** Symbol.keyFor called through its function value: the key or
+         * undefined, or Node's TypeError for a value that is not a symbol. */
+        "sym.keyForDyn": { argTypes: [DYN], result: DYN },
         /** Engine-free arbitrary-precision bigint operations (scr_bigint.c).
          * parse accepts the ECMAScript BigInt string grammar; fromF64 accepts
          * finite integral Numbers. Arithmetic returns fresh immutable values.
@@ -1076,6 +1145,10 @@ function buildLibFnSignatures() {
         "url.canParseBase": { argTypes: [STRING, STRING], result: BOOL },
         "url.parse": { argTypes: [STRING], result: DYN },
         "url.parseBase": { argTypes: [STRING, STRING], result: DYN },
+        /** URL.revokeObjectURL(id): the id arrives already converted. A
+         * compiled program registers no blob URLs, so Node's registry lookup
+         * always misses and the call answers undefined. Never throws. */
+        "url.revokeObjectURL": { argTypes: [STRING], result: VOID },
         "url.protocol": { argTypes: [URL_T], result: STRING },
         "url.origin": { argTypes: [URL_T], result: STRING },
         "url.username": { argTypes: [URL_T], result: STRING },
@@ -1294,17 +1367,18 @@ function buildLibFnSignatures() {
         "fs.statfsSync": { argTypes: [DYN, DYN], result: DYN },
         "fs.readlinkSyncStr": { argTypes: [DYN, DYN], result: STRING },
         "fs.readlinkSyncBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
-        /** fs.openSync(path, flags) → the raw fd as f64; fs.readSync/fs.writeSync
-         * over Buffer windows perform sequential I/O when position is -1 and
-         * offset-preserving positioned I/O otherwise; fs.writeStrSync is the
-         * utf8 string twin; and fs.closeSync(fd) closes the descriptor. This is
-         * the fd slice behind spawn/log-processing forms.
+        /** fs.openSync(path, flags, mode) → the raw fd as f64; fs.readSync/
+         * fs.writeSync over Buffer windows perform sequential I/O when position
+         * is -1 and offset-preserving positioned I/O otherwise; fs.writeStrSync
+         * is the utf8 string twin; and fs.closeSync(fd) closes the descriptor.
+         * This is the fd slice behind spawn/log-processing forms.
          * flags is Node's string
          * grammar ("r", "w", "a" and the +/x variants; unknown flags throw
-         * Node's ERR_INVALID_ARG_VALUE TypeError text). All throw Node-shaped
-         * fs errors (openSync ENOENT/EACCES..., readSync EBADF/range errors,
-         * closeSync EBADF). */
-        "fs.openSync": { argTypes: [STRING, STRING], result: F64 },
+         * Node's ERR_INVALID_ARG_VALUE TypeError text), and mode is open(2)'s
+         * creation mode (Node's 0o666 default, ERR_OUT_OF_RANGE outside
+         * 0..0xFFFFFFFF). All throw Node-shaped fs errors (openSync
+         * ENOENT/EACCES..., readSync EBADF/range errors, closeSync EBADF). */
+        "fs.openSync": { argTypes: [STRING, STRING, F64], result: F64 },
         "fs.openNumericSync": { argTypes: [STRING, F64, F64], result: F64 },
         "fs.readSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
         "fs.readSyncDyn": { argTypes: [DYN, DYN, DYN, DYN, DYN], result: F64 },
@@ -1578,6 +1652,40 @@ function buildLibFnSignatures() {
             argTypes: [STRING, arrayOf(STRING), F64, STRING, STRING],
             result: SPAWNRES_T,
         },
+        /** spawnSync with the `cwd`, `input`, and `shell` options (the
+         * SCR_CHILD_CP_OPTIONS build of scr_child.c): the cp.spawnSyncOpts
+         * contract plus the child's working directory ("" = inherit), stdin
+         * input (has_input false leaves fd 0 to the stdio mode — an absent
+         * `input` option; "" pipes an empty stdin), and the shell form
+         * (the complete command line through /bin/sh -c — the compiler emits
+         * it with an empty args list only, since Node warns DEP0190 for
+         * separate shell arguments), exactly Node's reading of the members.
+         * Args (cmd, argv, timeout, killSignal, inMode, outMode, errMode,
+         * cwd, input, hasInput, shell). Never throws, like every spawnSync
+         * form. */
+        "cp.spawnSyncExt": {
+            argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64, STRING, STRING, BOOL, BOOL],
+            result: SPAWNRES_T,
+        },
+        /** cp.spawnSyncExt with the `env` option: the trailing [k,v,...] pairs
+         * replace the child's environment. */
+        "cp.spawnSyncExtEnv": {
+            argTypes: [
+                STRING,
+                arrayOf(STRING),
+                F64,
+                STRING,
+                F64,
+                F64,
+                F64,
+                STRING,
+                STRING,
+                BOOL,
+                BOOL,
+                arrayOf(STRING),
+            ],
+            result: SPAWNRES_T,
+        },
         // node:net (scr_net.c). Listener slots are program-dependent closures —
         // null slots, checked in the libCall case (the child.onExit precedent);
         // the zero-param callbacks pin the exact func type here. The trailing
@@ -2148,6 +2256,11 @@ function buildLibFnSignatures() {
          * per-shape adapter — the tags are program data). */
         "http.serverOnConnect": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
         "http.clientOnUpgrade": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
+        /** server.on("clientError", (err, socket) => ...): a request the parser
+         * rejects, or a connection error, goes to the listeners instead of the
+         * default 400/413/431 answer, as in Node. (err, socket) and shorter
+         * prefixes (the libCall case checks). */
+        "http.serverOnClientError": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
         "http.reqSocket": { argTypes: [HTTPREQ_T], result: NETSOCKET_T },
         // reqH2Stream's program-interned Http2Stream | undefined result is
         // checked in the special libCall cases in validate.ts.
@@ -2256,6 +2369,11 @@ function buildLibFnSignatures() {
         "http.clientSignal": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
         /** options.signal checked before the request is built (ERR_INVALID_ARG_TYPE). */
         "http.clientSignalCheck": { argTypes: [DYN], result: VOID },
+        /** options.protocol checked before the request is built: the declared
+         * scheme against the agent's (the calling module's when the options
+         * carry no Agent value). MAY THROW ERR_INVALID_PROTOCOL. */
+        "http.clientProtocolCheck": { argTypes: [DYN, BOOL], result: VOID },
+        "http.clientProtocolCheckAgent": { argTypes: [DYN, BOOL, DYN], result: VOID },
         /** https.request's servername option, stored for the construction call
          * that follows: the TLS name sent and verified, and part of the pooled
          * socket key. The "https." prefix keeps the TLS unit linked. */
@@ -2300,6 +2418,13 @@ function buildLibFnSignatures() {
         "http.requestDynCb": { argTypes: [DYN, BOOL, null], result: HTTPCLIENTREQ_T },
         "https.requestDyn": { argTypes: [DYN, BOOL], result: HTTPCLIENTREQ_T },
         "https.requestDynCb": { argTypes: [DYN, BOOL, null], result: HTTPCLIENTREQ_T },
+        /** request/get with a URL and an options record: Node's
+         * `{...urlToHttpOptions(new URL(url)), ...options}` merge at run time,
+         * then the walk above. Args (url, options, autoEnd[, cb]). MAY THROW. */
+        "http.requestUrlDyn": { argTypes: [STRING, DYN, BOOL], result: HTTPCLIENTREQ_T },
+        "http.requestUrlDynCb": { argTypes: [STRING, DYN, BOOL, null], result: HTTPCLIENTREQ_T },
+        "https.requestUrlDyn": { argTypes: [STRING, DYN, BOOL], result: HTTPCLIENTREQ_T },
+        "https.requestUrlDynCb": { argTypes: [STRING, DYN, BOOL, null], result: HTTPCLIENTREQ_T },
         /** The paused-mode demux surface (portless's first-byte TLS peek:
          * once('readable') + read(1) + unshift + emit('connection')).
          * sockOnReadable registers a zero-param listener (a consumer: arrived
@@ -2826,10 +2951,11 @@ function buildLibFnSignatures() {
             argTypes: [STRING, arrayOf(STRING), BOOL, STRING, BOOL, arrayOf(STRING), F64],
             result: SPAWNRES_T,
         },
-        /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawnp
-         * with per-slot ignore/inherit/pipe modes (and number output fds), the
-         * all-piped Node default, and the child registered with the event loop,
-         * which polls waitpid(WNOHANG) at quiescence like timers.
+        /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawn
+         * after the PATH search in the parent, with per-slot ignore/inherit/pipe
+         * modes (and number output fds), the all-piped Node default, and the
+         * child registered with the event loop, which polls waitpid(WNOHANG) at
+         * quiescence like timers.
          * NEVER throws: spawn failure defers to the "error" event, Node-exact
          * (the error message is Node's "spawn <cmd> <ERRNO-NAME>"; an "error"
          * event with no listener prints it and exits 1 like an EventEmitter).
@@ -2890,6 +3016,13 @@ function buildLibFnSignatures() {
          * by the validator/backends. The last argument is exec's shell flag:
          * the argv is ["-c", command] and failure messages show the command. */
         "cp.execFile": { argTypes: [STRING, arrayOf(STRING), null, BOOL], result: CHILD_T },
+        /** The same callback slice with the `cwd` option (the
+         * SCR_CHILD_CP_OPTIONS build): the child starts in cwd.
+         * (cmd, argv, callback, shell, cwd). */
+        "cp.execFileCwd": {
+            argTypes: [STRING, arrayOf(STRING), null, BOOL, STRING],
+            result: CHILD_T,
+        },
         // spawn's options form: per-slot stdio modes (0 ignore / 1 inherit /
         // 2 fd) with the out/err fds for mode 2, detached, env replacement
         // pairs, cwd ("" = inherit).
@@ -3327,6 +3460,20 @@ function buildLibFnSignatures() {
         /** Buffer.byteLength as a function value: the encoding arrives at run time. */
         "buffer.byteLenValue": { argTypes: [DYN, DYN], result: F64 },
         "buffer.byteLenStr": { argTypes: [STRING, STRING], result: F64 },
+        /** A run-time Buffer encoding name, normalized the way the method's
+         * owner reads it. normalizeEncoding is Node's getEncodingOps (empty and
+         * unknown names throw ERR_UNKNOWN_ENCODING); normalizeEncodingEmptyUtf8
+         * is Node's normalizeEncoding (an empty name reads as utf8, unknown
+         * names throw); normalizeEncodingOrUtf8 is Buffer.byteLength's read (an
+         * unknown name counts as utf8, nothing throws). */
+        "buffer.normalizeEncoding": { argTypes: [STRING], result: STRING },
+        "buffer.normalizeEncodingEmptyUtf8": { argTypes: [STRING], result: STRING },
+        "buffer.normalizeEncodingOrUtf8": { argTypes: [STRING], result: STRING },
+        /** buf.write with an encoding name known only at run time: Node checks
+         * the offset and length BEFORE it reads the name, so the raw value goes
+         * to the runtime and the range errors win over an unknown name. */
+        "buffer.writeStrDyn": { argTypes: [BYTES_U8, STRING, STRING, F64], result: F64 },
+        "buffer.writeStrDynLen": { argTypes: [BYTES_U8, STRING, STRING, F64, F64], result: F64 },
         "buffer.isEncoding": { argTypes: [STRING], result: BOOL },
         /** Buffer.concat(list, totalLength): the concatenation truncated or
          * zero-padded to the total. THROWS Node's 'length' RangeError on a
@@ -3358,6 +3505,8 @@ function buildLibFnSignatures() {
         "buffer.installValue": { argTypes: [], result: VOID },
         "buffer.staticValue": { argTypes: [STRING], result: DYN },
         "buffer.prototypeMember": { argTypes: [DYN], result: DYN },
+        "buffer.prototypeObject": { argTypes: [], result: DYN },
+        "buffer.slowBuffer": { argTypes: [DYN], result: BYTES_U8 },
         /** fs._toUnixTimestamp(time) over a dyn value: numeric strings and
          * finite numbers coerce (negatives answer now/1000, Node's shape);
          * everything else throws Node's ERR_INVALID_ARG_TYPE. May-throw. */
@@ -3485,6 +3634,8 @@ function buildLibFnSignatures() {
          * receivers are borrowed. */
         /** Connects scr_brotli.c to the zlib engine (%main, before any module). */
         "zlib.brotliInstall": { argTypes: [], result: VOID },
+        /** Connects scr_zstd.c the same way. */
+        "zlib.zstdInstall": { argTypes: [], result: VOID },
         "zlib.streamNew": { argTypes: [F64, DYN], result: VOID },
         "zlib.streamBytesWritten": { argTypes: [null], result: F64 },
         /** `stream instanceof zlib.Gzip`: the borrowed stream and the class's
@@ -3751,6 +3902,14 @@ function buildLibFnSignatures() {
          * (0 String, 1 Number, 2 Boolean), the value it converts, and the three
          * constructor values for the prototypes' `constructor`. */
         "wrapper.new": { argTypes: [F64, DYN, DYN, DYN, DYN], result: DYN },
+        /** %Iterator.prototype% and %Iterator% (scr_js_iterator.c), `new
+         * Iterator()` (always the abstract-class TypeError), Iterator.from over
+         * a checked value, and OrdinaryHasInstance(%Iterator%, value). */
+        "iterator.prototype": { argTypes: [], result: DYN },
+        "iterator.constructor": { argTypes: [], result: DYN },
+        "iterator.construct": { argTypes: [], result: DYN },
+        "iterator.from": { argTypes: [DYN], result: DYN },
+        "iterator.instanceOf": { argTypes: [DYN], result: BOOL },
         /** ToObject (scr_js_wrapper_to_object): a wrapper for a primitive, the
          * value for an object, a fresh object for null/undefined; then the
          * three constructor values. */
@@ -3774,6 +3933,12 @@ function buildLibFnSignatures() {
          * (scr_js_wrapper_this_string). */
         "wrapper.isStringMethod": { argTypes: [DYN, STRING], result: BOOL },
         "wrapper.thisString": { argTypes: [DYN, STRING], result: DYN },
+        /** Boolean.prototype as a value in a JavaScript source: the wrapper
+         * unit's Boolean prototype object (the one `new Boolean(v)` instances
+         * inherit from), so its valueOf/toString accept a primitive boolean or
+         * a Boolean wrapper receiver and throw Node's brand-check TypeError for
+         * a foreign one. `constructor` is the compiled Boolean constructor. */
+        "wrapper.booleanPrototype": { argTypes: [DYN], result: DYN },
         "fs.callbackValue": { argTypes: [STRING], result: DYN },
         "fs.callbackCall": { argTypes: [STRING, DYN], result: DYN },
         "process.hrtimeValue": { argTypes: [], result: DYN },
@@ -3957,10 +4122,20 @@ function buildLibFnSignatures() {
         "console.clear": { argTypes: [], result: VOID },
         "console.table": { argTypes: [DYN, DYN], result: VOID },
         "console.dirDyn": { argTypes: [DYN, F64], result: STRING },
+        "console.dirHidden": { argTypes: [DYN, F64], result: STRING },
         /** A native reference to the global object; known names retain value fences. */
         "global.native": { argTypes: [arrayOf(STRING)], result: DYN },
+        /** Arms the runtime check for the Node globals the native runtime does not
+         * implement (host-globals.ts): the compiler's derived name table. */
+        "global.hostAbsent": { argTypes: [arrayOf(STRING)], result: VOID },
+        /** `key in globalThis`: the host-global check, then the global object's
+         * own presence answer (scr_global_host_absent.c). */
+        "dyn.globalHas": { argTypes: [STRING], result: BOOL },
         /** Installs the program's builtin-global lookup (global-values.ts). */
         "global.installValues": { argTypes: [DYN], result: VOID },
+        /** Installs the program's static-member lookup for builtin constructor
+         * values (builtin-statics.ts). */
+        "dyn.installBuiltinStatics": { argTypes: [DYN], result: VOID },
         /** The keys `for (key in globalThis)` visits, as a fresh object. */
         "global.forInObject": { argTypes: [], result: DYN },
         /** Node's navigator global (scr_node_builtin.c). */
@@ -4075,6 +4250,15 @@ function buildLibFnSignatures() {
         "sharedArrayBuffer.new": { argTypes: [DYN], result: DYN },
         "sharedArrayBuffer.is": { argTypes: [DYN], result: BOOL },
         "arrayBuffer.new": { argTypes: [DYN], result: DYN },
+        /** `new ArrayBuffer(len, { maxByteLength })` in a JavaScript source
+         * (t262-dc C2): the maxByteLength reserved up front, the visible length
+         * len. */
+        "arrayBuffer.newResizable": { argTypes: [DYN, DYN], result: DYN },
+        /** `new SharedArrayBuffer(len, { maxByteLength })`: the same, growable. */
+        "sharedArrayBuffer.newGrowable": { argTypes: [DYN, DYN], result: DYN },
+        /** The %main prologue call that arms scr_js_buffers's views registry
+         * (buffers.ts): never throws, never answers. */
+        "arrayBuffer.armMutable": { argTypes: [], result: VOID },
         "ffi.argument": { argTypes: [DYN, STRING], result: DYN },
         "ffi.memoryModule": { argTypes: [DYN], result: DYN },
         "intl.segmenterNew": { argTypes: [], result: DYN },
@@ -4217,6 +4401,13 @@ function buildLibFnSignatures() {
         "dyn.isExtensible": { argTypes: [DYN], result: BOOL },
         "dyn.seal": { argTypes: [DYN], result: DYN },
         "dyn.isSealed": { argTypes: [DYN], result: BOOL },
+        /** Object.isExtensible / Object.isSealed of a value whose kind is known
+         * only at runtime: a native handle or a promise has no modeled integrity
+         * state, so these refuse (SC2020) instead of answering like
+         * dyn.isExtensible/dyn.isSealed, which the static arms (a class
+         * instance's checked view, a typed function value) keep using. */
+        "dyn.isExtensibleQuery": { argTypes: [DYN], result: BOOL },
+        "dyn.isSealedQuery": { argTypes: [DYN], result: BOOL },
         "dyn.objValues": { argTypes: [DYN], result: DYN },
         /** Object.values as a native vector of checked values, for results the
          * program consumes directly (for-of, index reads, read-only methods). */
@@ -4970,9 +5161,27 @@ function buildLibFnSignatures() {
          * 'not supported yet' Error. */
         "insp.dynHidden": { argTypes: [DYN, F64], result: STRING },
         "insp.begin": { argTypes: [F64], result: VOID },
-        /** util.inspect's breakLength, compact (-1 for false) and sorted for the
-         * renders that follow; the call site restores 80, 3 and false afterwards. */
-        "insp.layout": { argTypes: [F64, F64, BOOL], result: VOID },
+        /** util.inspect's breakLength, compact (-1 for false), sorted and
+         * maxArrayLength (Infinity for null) for the renders that follow; the
+         * call site restores 80, 3, false and 100 afterwards. */
+        "insp.layout": { argTypes: [F64, F64, BOOL, F64], result: VOID },
+        /** The render's maxArrayLength, which the array, Map and Set traversals
+         * read: the option applies at every nesting level. */
+        "insp.maxArrayLength": { argTypes: [], result: F64 },
+        /** ctx.maxStringLength for the renders that follow; answers the previous
+         * value so the call site can restore it. */
+        "insp.maxStringLength": { argTypes: [F64], result: F64 },
+        /** ctx.getters for the renders that follow: whether an accessor
+         * property's getter runs (0 the labels only, 1 every getter, 2 the
+         * getters without a setter, 3 the getters with one); answers the previous
+         * value so the call site can restore it. */
+        "insp.getters": { argTypes: [F64], result: F64 },
+        /** The current ctx.getters, which the interned per-type helpers read: the
+         * option is run-time state shared by every call site. */
+        "insp.gettersMode": { argTypes: [], result: F64 },
+        /** An invoked accessor property's value, by the result's kind:
+         * `[Label: <primitive>]` or `[Label] <object>`. */
+        "insp.accessorValue": { argTypes: [DYN, STRING, F64, F64], result: STRING },
         "insp.entry": { argTypes: [STRING, BOOL], result: VOID },
         // Circular references: the receiver slot is program-dependent (any
         // cycle-capable record/array/map/class type — the insp.error precedent).
@@ -4995,6 +5204,21 @@ function buildLibFnSignatures() {
          * (key-order-witness.ts ordered spreads). Both are record types. Never
          * throws. */
         "record.sourceSpread": { argTypes: [null, null], result: VOID },
+        /** `record.sourceShare(built, value)`: the record `built`, of value's
+         * record type, keeps value's kept source too (record-links.ts compose
+         * helpers). Never throws. */
+        "record.sourceShare": { argTypes: [null, null], result: VOID },
+        /** `record.link(copy, source, pair)`: the copy a narrowing conversion
+         * just built links to its source record (IrModule.recordLinks; `pair`
+         * a numLit). Borrows both. Never throws. */
+        "record.link": { argTypes: [null, null, F64], result: VOID },
+        /** `record.linkIs(copy, pair)`: whether the record links to a source
+         * through the pair (a numLit). Never throws. */
+        "record.linkIs": { argTypes: [null, F64], result: BOOL },
+        /** `record.linkSource(copy, pair)`: the source a record links to
+         * through the pair, which the caller has tested (record.linkIs); its
+         * type is the pair's source type. Never throws. */
+        "record.linkSource": { argTypes: [null, F64], result: VOID },
         /** `record.sourceNote(built, keys)`: the record a width spread just
          * built keeps `keys` (the copy's own keys, in order; declared ones are
          * placeholders) as its kept source when they hold an undeclared key or
@@ -5010,6 +5234,8 @@ function buildLibFnSignatures() {
          * `prefix inner` re-indented at the caller's level (+1). */
         "insp.nestedBegin": { argTypes: [], result: VOID },
         "insp.nestedEnd": { argTypes: [STRING, STRING], result: STRING },
+        /** nestedEnd's restore alone: the caller's context returns. */
+        "insp.nestedRestore": { argTypes: [], result: VOID },
         /** Around a top-level render that an inspection refusal can end: mark
          * records the inspector's frame and nesting depth, unwind (in the
          * render's finally) closes what the render left open above it. */