@scriptc/compiler 0.4.2 → 0.4.3

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 },
@@ -1267,6 +1295,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 +1511,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 +1808,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 +1875,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 +2811,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 },
@@ -3351,6 +3406,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 +3603,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 +3729,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 +3740,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 +3768,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 +3813,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 +3965,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 +3995,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 +4040,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 +4102,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 +4164,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 },
@@ -4675,6 +4822,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 +4903,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++;