@scriptc/compiler 0.2.3 → 0.2.5

package/dist/ir/ir.d.ts

@@ -1,3 +1,5 @@
+import type { IrLibFn } from "./builtin-signatures.js";
+export type { IrLibFn } from "./builtin-signatures.js";
 /** Byte-offset span in the original source file. */
 export interface SrcLoc {
     file: string;
@@ -420,11 +422,11 @@ interface IrKindSet<K extends IrType["kind"]> extends ReadonlySet<IrType["kind"]
 /** The opaque runtime handle kinds. procStream is the one scalar handle;
  * every other handle has pointer representation. */
 declare const HANDLE_KIND_LIST: readonly ["stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "procStream"];
-export type HandleKind = typeof HANDLE_KIND_LIST[number];
+export type HandleKind = (typeof HANDLE_KIND_LIST)[number];
 export declare const HANDLE_KINDS: IrKindSet<"child" | "childStream" | "childWriter" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "fileHandle" | "fsWatcher" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "netServer" | "netSocket" | "procStream" | "secureCtx" | "spawnRes" | "stats" | "testCtx">;
 /** The IR kinds represented as pointers in native code. */
 declare const POINTER_KIND_LIST: readonly ["string", "bigint", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "func", "object", "classval", "moduleNs", "record", "union", "dyn", "jsval", "caught", "promise", "generator"];
-export type PointerKind = typeof POINTER_KIND_LIST[number];
+export type PointerKind = (typeof POINTER_KIND_LIST)[number];
 export declare const POINTER_KINDS: IrKindSet<"array" | "bigint" | "bytes" | "caught" | "child" | "childStream" | "childWriter" | "classval" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "dyn" | "fileHandle" | "fsWatcher" | "func" | "generator" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "jsval" | "map" | "moduleNs" | "netServer" | "netSocket" | "object" | "promise" | "record" | "regex" | "searchParams" | "secureCtx" | "set" | "spawnRes" | "stats" | "string" | "symbol" | "testCtx" | "union" | "url">;
 /** Runtime RC symbol stem for each IR type kind. An empty stem means the
  * kind is scalar/unit or uses an emitted per-shape helper (object/record).
@@ -494,9 +496,10 @@ export declare function setOf(elem: IrType): IrType;
  * classes and arrays can point back at their collection, so constructors
  * must carry key tracing as well as retain/release adapters. */
 export declare function isIdentityCollectionKey(t: IrType): boolean;
-/** Numbers use SameValueZero, strings use content, and reference keys use
- * identity. A union of identity arms hashes its payload, never its temporary
- * wrapper. Mixed scalar/reference unions remain outside this contract. */
+/** Primitive keys compare by value and reference keys by identity. Union
+ * wrappers carry either domain without becoming observable key identities;
+ * null and undefined are distinct tag-only keys inside a union. */
+export declare function isPrimitiveCollectionKey(t: IrType, unionArms?: IrType[]): boolean;
 export declare function isSupportedMapKey(t: IrType, unionArms?: IrType[]): boolean;
 /** Set elements and Map keys share storage, equality and ownership rules. */
 export declare function isSupportedSetElem(t: IrType, unionArms?: IrType[]): boolean;
@@ -1418,6 +1421,8 @@ export type IrArrIntrinsicMethod = "length"
  | "flatCopy" | "flatOne"
 /** Mutating splice with evaluated insertion items; returns removed slots. */
  | "spliceInsert" | "reverse"
+/** Evaluated numeric bounds; same-type fill values stay borrowed. */
+ | "copyWithin" | "fill" | "fillUndefined"
 /** ES2023 copying methods. `toSpliced` receives [start, deleteCount,
  * itemsArray], with omitted arguments completed by the frontend;
  * `with` receives [index, value] and throws Node's catchable RangeError
@@ -1438,13 +1443,15 @@ export declare const MAY_THROW_ARR_METHODS: ReadonlySet<IrArrIntrinsicMethod>;
  * callback mutation because the runtime never compacts between
  * `iterEnter`/`iterExit` — live-iteration semantics, Node-exact). The iter*
  * members are compiler-internal: no ambient declaration reaches them. */
-export type IrMapIntrinsicMethod = "get" | "set" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterLive" | "iterKey" | "iterValue" | "iterEnter" | "iterExit";
+export type IrMapIntrinsicMethod = 
+/** Internal shallow-copy constructors over builtin collection storage. */
+"clone" | "keySet" | "valueSet" | "get" | "set" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterLive" | "iterKey" | "iterValue" | "iterEnter" | "iterExit";
 /** The Set method/property surface — Map's minus get/set/iterValue (there
  * is no value slot; `add` fills set's role) plus `add`. `forEach` desugars
  * in the frontend exactly like Map's, over the same iteration primitives —
  * iterKey doubles as the element read (JS's Set forEach passes the element
  * as both `value` and `key`). */
-export type IrSetIntrinsicMethod = "add" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterLive" | "iterKey" | "iterEnter" | "iterExit"
+export type IrSetIntrinsicMethod = "clone" | "add" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterLive" | "iterKey" | "iterEnter" | "iterExit"
 /** `[...set]` and friends: drain the live entries into a FRESH elem[]
  * in insertion order (tombstones skipped — the same walk the forEach
  * desugar does, folded into one runtime call; no user code runs during
@@ -1592,1899 +1599,6 @@ export type IrRegexIntrinsicMethod = "test" | "match"
  * no g/y fence applies: /g is irrelevant and /y anchors at 0 — exactly
  * Node. Never throws. */
  | "search" | "source" | "flags" | "toString" | "replace" | "replaceAll" | "split";
-/** The complete standard-library surface (mirrors ambient/scriptc.d.ts: the
- * `process` and `JSON` globals and `declare module "node:fs"`). A closed
- * union — every member has a signature in the validator's LIB_FN_SIGS and a
- * scr_* implementation in the runtime (scr_lib.c / scr_json.c). fs.*
- * failures and json.parse syntax errors THROW (catchable, via the runtime
- * exception cell); process.* members never throw. JSON.stringify without a
- * callback lowers to the type-directed `jsonStringify` node below; callback
- * forms use the shared native JSON walker through libCall.
- * island.eval (the internal __island_eval testing hook) exists only in
- * --dynamic builds — the frontend rejects it otherwise, so backends may
- * assume the island runtime is linked when they see it; island exceptions
- * bridge into the exception cell as catchable strings (may-throw). */
-export type IrLibFn = "ffi.argument" | "ffi.memoryModule" | "intl.segmenterNew" | "weakMap.is" | "weakSet.is" | "weakMap.new" | "weakSet.new" | "dyn.fromEntries" | "bytes.constructor" | "bytes.instanceOf" | "bytes.construct" | "arrayBuffer.constructor" | "arrayBuffer.new" | "arrayBuffer.is" | "arrayBuffer.isView" | "arrayBuffer.byteLengthGetter" | "arrayBuffer.byteLengthDescriptor" | "arrayBuffer.viewU8C" | "arrayBuffer.viewI8" | "arrayBuffer.viewU16" | "arrayBuffer.viewI16" | "arrayBuffer.viewU8" | "arrayBuffer.viewU32" | "arrayBuffer.viewI32" | "arrayBuffer.viewF32" | "arrayBuffer.viewF64" | "arrayBuffer.viewDV"
-/** Native static fetch and its Web-platform companions. fetch.start
- * answers once the response head arrives; the response body readers
- * consume the native body stream. AbortSignal and ReadableStream values
- * are opaque checked-dynamic handles. */
- | "fetch.start" | "fetch.input" | "fetch.function" | "fetch.requestNew" | "fetch.headersNew" | "fetch.responseNew" | "fetch.responseArrayBuffer" | "fetch.responseJson" | "fetch.responseText" | "fetch.responseBytes" | "fetch.abortControllerNew" | "fetch.abortTimeout" | "fetch.abortNow" | "fetch.abortAny" | "abort.controllerNew" | "abort.timeout" | "abort.now" | "abort.any" | "fetch.webIs" | "fetch.streamIs" | "fetch.streamNew" | "fetch.streamFrom" | "fetch.readerRead" | "island.eval"
-/** Load an embedded npm package's runtime entry in the island (cached by
- * the engine's module registry) and take one export: args are the entry
- * KEY (an embedded module's key, from IrModule.embedded) and the export
- * name — "default" for default imports, "*" for the namespace object.
- * --dynamic only, like island.eval; result is an owned jsval. May throw
- * (a package's top-level code can), bridged catchably. */
- | "island.import"
-/** Dynamic `import(spec)`: load a module through the island's module
- * system — an embedded module's key or a builtin shim's "node:x" key —
- * and answer an ENGINE promise of its namespace object (always a
- * promise, never a throw: load and evaluation failures REJECT it,
- * Node's shape). The frontend wraps the result in jsBridgePromise, so
- * awaiting parks the fiber and a rejection crosses catchably. --dynamic
- * only; result is an owned jsval holding the engine promise. */
- | "island.importDyn"
-/** A checked cast the boundary can never satisfy, DEFERRED to runtime:
- * `islandValue as Promise<T>` — the value is an ENGINE promise and T
- * has no validated exit (Node-typed async APIs put class-shaped
- * interfaces there), so instead of refusing the build the cast throws a
- * catchable TypeError AT THE CAST naming the target type (args: the
- * island value — evaluated, borrowed — and the type name). The result
- * type is the cast's mapped target (a typed dummy; the exception is
- * pending). Documented divergence: JS `as` never checks — like the dyn
- * boundary, a conversion that cannot happen throws instead of lying.
- * --dynamic only. */
- | "island.castFail" | "json.parse" | "json.parseReviver" | "json.stringifyReplacer" | "json.stringifyValue"
-/** 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
- * OBJ receiver sets the member (later writes win, insertion order
- * preserved — JS exactly); undefined/null throws Node's catchable
- * "Cannot set properties of undefined (setting 'k')"; every other kind
- * throws Node's STRICT-mode "Cannot create property 'k' on <kind>" —
- * primitives quoting their rendering, V8's "on number '5'"
- * (sloppy mode would silently ignore — suite tests are 'use strict';
- * SEMANTICS.md notes the sloppy divergence: loud, never silent). Void
- * result; in the may-throw seed set. */
- | "dyn.keySet" | "dyn.keySetComputed"
-/** Delete an ordinary checked-native object's own key. Borrows both
- * arguments; other receiver representations retain a runtime refusal. */
- | "dyn.keyDelete" | "dyn.keyDeleteComputed" | "dyn.hasKeyComputed" | "dyn.hasOwnComputed" | "dyn.propertyIsEnumerableComputed"
-/** Native own properties on globalThis keyed by symbol identity. */
- | "dyn.globalSymbolGet" | "dyn.globalSymbolSet" | "dyn.globalSymbolHas" | "dyn.globalSymbolDelete"
-/** Exact native class capsule identity, without materializing its fields. */
- | "dyn.typedRefIs" | "dyn.classIs"
-/** 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;
- * result: a fresh dyn array, +1). Iterable kinds collect like spread
- * (arrays element-by-element, strings by code point, bytes by byte);
- * every other kind throws V8's destructuring TypeError — the spelling
- * verbatim when non-empty, else the runtime kind wording ("number 5 is
- * not iterable (cannot read property Symbol(Symbol.iterator))"). In the
- * may-throw seed set. */
- | "dyn.iterPack" | "dyn.arrayFromIterator" | "dyn.iterator" | "dyn.iteratorResult" | "dyn.mapSeedEntries" | "dyn.mapSeedEntry"
-/** The for-of-over-dyn pack accessors — the emitted index loop drives
- * them over a dyn.iterPack result (ARR by construction). arrLen: the
- * ARR length as f64 (0 for non-ARR kinds; arg borrowed). arrAt: the
- * element at index (+1; the undefined singleton past the end). Neither
- * throws. */
- | "dyn.arrLen" | "dyn.arrAt"
-/** `key in v` with a RUNTIME (string) key on a checked-dynamic
- * receiver (args: value dyn, key string; result bool): OBJ answers
- * own-member presence, ARR answers 'length'/a valid index — exactly
- * the literal-key dynHasKey path. Proxy has traps may throw. */
- | "dyn.hasKey"
-/** Object.defineProperties over dyn values (args: target, descriptors —
- * both borrowed dyn; result: the target, +1 — JS's return value).
- * Value descriptors become own properties on OBJ and FUNC targets;
- * OBJ targets preserve data attributes. get/set
- * descriptors and non-object targets/descriptors throw catchably
- * (Node's TypeError texts; accessors the loud unsupported Error). In
- * the may-throw seed set. */
- | "dyn.defineProps" | "dyn.defineProperty" | "dyn.getOwnPropertyDescriptor" | "dyn.arrayProtoCall" | "dyn.promiseAll"
-/** 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
- * wart preserved), boolean/number/string by kind, function→"function".
- * Never throws. */
- | "dyn.typeof"
-/** Object.prototype.toString.call on a checked-dynamic value. */
- | "dyn.objectTag" | "dyn.freeze" | "dyn.isFrozen" | "dyn.nativeSetNew" | "dyn.nativeSetIs" | "dyn.nativeMapIs" | "dyn.nativeUrlIs" | "dyn.nativeDateIs" | "date.nativeNew" | "date.checkedValue" | "dyn.nativeRegexIs"
-/** toString() on a checked-dynamic receiver: runtime kind dispatch
- * (bytes decode per the literal encoding — utf8 default; strings,
- * numbers, booleans, arrays, objects answer JS-exactly; undefined and
- * null throw the catchable TypeError). */
- | "dyn.toString"
-/** Engine-free CommonJS module graph. Module values are scalar f64
- * handles; generated startup defines the registry, init wrappers update
- * loading/cache state, and the read surface answers Node's live metadata. */
- | "module.registryInit" | "module.define" | "module.enter" | "module.link" | "module.finish" | "module.fail" | "module.filename" | "module.id" | "module.path" | "module.paths" | "module.children" | "module.parent" | "module.loaded" | "module.cacheGet" | "module.cacheHas" | "module.cacheKeys" | "fs.readFileSync"
-/** readFileSync(path) — the Buffer read (+1 bytes); throws catchably
- * like the utf8 form. */
- | "fs.readFileSyncBuf"
-/** readFileSync(path, enc) with a RUNTIME encoding (an untyped JS
- * parameter): undefined/null answer Buffers, utf8 a string, other real
- * encodings fence loudly, unknown names throw ERR_UNKNOWN_ENCODING. */
- | "fs.readFileSyncDyn" | "fs.writeFileSync" | "fs.appendFileSync" | "fs.existsSync" | "fs.mkdirSync" | "fs.rmSync" | "fs.rmdirSync" | "fs.readdirSync"
-/** node:path (scr_path.c ports BOTH of Node's implementations
- * function-by-function): the `path.*` family is posix, the
- * `path.win32*` family is Node v24's path.win32 byte-for-byte — the
- * frontend binds the bare module to the TARGET platform's family
- * (Node on Windows IS path.win32) and the path.posix / path.win32
- * namespaces to their own family everywhere. join and resolve take ONE
- * string[] arg — the frontend packs the variadic call's arguments into
- * an array literal. basename always receives its suffix (the frontend
- * completes an omitted one with "", a Node no-op). toNamespacedPath is
- * the posix identity and the win32 \\?\-prefixer. None of these throw;
- * the resolves consult the process cwd like Node's. */
- | "path.join" | "path.resolve" | "path.normalize" | "path.dirname" | "path.basename" | "path.extname" | "path.isAbsolute" | "path.relative" | "path.toNamespacedPath" | "path.win32Join" | "path.win32Resolve" | "path.win32Normalize" | "path.win32Dirname" | "path.win32Basename" | "path.win32Extname" | "path.win32IsAbsolute" | "path.win32Relative" | "path.win32ToNamespacedPath"
-/** node:os: homedir is $HOME else getpwuid(3); tmpdir is Node's env
- * cascade ($TMPDIR/$TMP/$TEMP else /tmp, one trailing slash trimmed).
- * os.platform() lowers to process.platform — one implementation. */
- | "os.homedir"
-/** os.release(): uname(2)'s release field — Node's own implementation
- * (the kernel version string, e.g. "24.6.0" on macOS 15). Interned; +1
- * per read. Never throws. */
- | "os.release"
-/** The os.userInfo() field trio (uv_os_get_passwd's slices): pw_name,
- * pw_shell, pw_dir — the PASSWD homedir, not os.homedir's $HOME-first
- * cascade (Node's own split). The frontend assembles the UserInfo
- * record from these plus getuid/getgid. +1 fresh strings; a passwd
- * lookup failure aborts (Node throws a system error there — no
- * compiled program path reaches it for the running uid). */
- | "os.userName" | "os.userShell" | "os.userHomedir" | "os.tmpdir"
-/** os.networkInterfaces(): getifaddrs(3) → the Dict<NetworkInterfaceInfo[]>
- * record, built inline by the emitter from a runtime snapshot (scr_lib.c).
- * The result type is the CALL SITE's mapped @types/node shape — a pure
- * index-signature record whose value is `Info[] | undefined`, Info a
- * two-record union (IPv4: scopeid `number | undefined` holding undefined;
- * IPv6: scopeid number) — verified structurally by the frontend. Rows
- * match libuv's filter (IFF_UP && IFF_RUNNING, AF_INET/AF_INET6; loopback
- * = internal; MACs from the interface's link-level sibling entry, zeros
- * when absent; cidr from the netmask's contiguous prefix, the null arm
- * when it is missing or non-contiguous). Key/row order follows the OS's
- * getifaddrs enumeration — Node itself does not guarantee an order.
- * Fresh +1 record; never throws (a getifaddrs failure yields {}). */
- | "os.networkInterfaces"
-/** `Math.max(...xs)` / `Math.min(...xs)` over one spread number[]
- * (scr_number.c): the JS fold exactly — any NaN element poisons the
- * result, ±0 order by the JS comparison (max prefers +0, min prefers
- * -0), and the empty array yields -Infinity / +Infinity like the
- * zero-argument calls. Borrows the array; never throws. */
- | "math.maxArr" | "math.minArr" | "math.hypotArr"
-/** `fs.readdirSync(path, { withFileTypes: true })` — Dirent rows over
- * one readdir pass (scr_lib.c's scandir snapshot; DT_UNKNOWN falls back
- * to lstat, Node's getDirents rule). The result type is the call site's
- * interned Dirent record array (name, parentPath, hidden %dtype in
- * libuv's UV_DIRENT encoding) — verified by the frontend; the emitter
- * assembles the rows from the snapshot. OS order, no "."/"..". Throws
- * Node's scandir errno error (may-throw seed set); fresh +1 array. */
- | "fs.readdirTypesSync"
-/** `Math.floor(x)` — C floor() IS the JS operation (NaN/±0/±Infinity
- * pass through bit-exactly). Never throws. */
- | "math.floor"
-/** `Math.min(a, b)` / `Math.max(a, b)` — the two-argument scalar forms
- * (scr_lib.c), JS-exact like the Arr folds: NaN poisons, max prefers +0
- * over -0 (min the reverse). C fmin/fmax are NOT these (they drop NaN).
- * Never throw. */
- | "math.min" | "math.max"
-/** `Math.random()` — a uniform double in [0,1) with the spec's 53-bit
- * granularity, drawn from arc4random_buf (the CSPRNG behind the crypto
- * lowerings). Same distribution as Node, NECESSARILY different sequence
- * (SEMANTICS.md 62 — no seeded sequence exists to match). Never throws. */
- | "math.random"
-/** Math.abs (C fabs — IS the JS operation) and Math.round (scr_lib.c:
- * ECMA half-toward-+Infinity with the exact-fraction comparison — C
- * round() is half-away-from-zero and floor(x+0.5) drifts at the
- * epsilon boundary). Borrow nothing; never throw. */
- | "math.abs" | "math.round"
-/** Math.trunc / Math.ceil — C trunc()/ceil() ARE the JS operations
- * (NaN/±0/±Infinity pass through bit-exactly; ceil(-0.5) is -0 in IEEE
- * round-toward-+Infinity exactly as ECMA says). Static like floor —
- * they are ask-4's wholeness-discharge operators, so the library
- * inference needs them compiled, not island-served. Never throw. */
- | "math.trunc" | "math.ceil" | "math.sin" | "math.sinh" | "math.cos" | "math.cosh" | "math.tan" | "math.tanh" | "math.asin" | "math.asinh" | "math.acos" | "math.acosh" | "math.atan" | "math.atanh" | "math.cbrt" | "math.clz32"
-/** Return -1, +1, or the original NaN/zero. In particular, -0 remains -0. */
- | "math.sign" | "math.exp" | "math.expm1" | "math.fround" | "math.sqrt" | "math.log" | "math.log1p" | "math.log2" | "math.log10" | "math.atan2" | "math.pow" | "math.imul"
-/** The static global parsers/tests (scr_string.c). num.parseInt is
- * ECMA-262 19.2.5 exactly — JS whitespace, sign, ToInt32 radix (the
- * frontend completes an omitted radix to 0 = the spec's "undefined":
- * base 10 with the 0x hex escape), longest digit prefix, and the exact
- * mathematical value correctly rounded (u64 fast path, bignum beyond —
- * overflow is ±Infinity). num.isNaN is the NaN self-test on an
- * already-number argument (tsc pins the argument to number, so no
- * ToNumber coercion exists to model). Borrow; never throw. */
- | "num.parseInt" | "num.isNaN"
-/** ES parseFloat (scr_string.c): the longest StrDecimalLiteral prefix
- * of the trimmed input (no hex, "Infinity" exact-case), NaN when none —
- * ECMA-262 19.2.4 over a string argument (non-string arguments keep the
- * fence: Node would ToNumber-coerce). Borrows; never throws. */
- | "num.parseFloat" | "num.fromString"
-/** The static URI component codecs (scr_string.c), ECMA-262 Encode/
- * Decode with the component sets over the runtime's UTF-8 strings.
- * str.encodeUriComponent percent-encodes every byte outside the
- * unreserved component set (ALPHA/DIGIT/- _ . ! ~ * ' ( )) as uppercase
- * %XX — the spec's per-code-point UTF-8 encoding IS a byte scan here —
- * and never throws (the spec's URIError case is an unpaired surrogate,
- * which cannot exist in well-formed UTF-8). str.decodeUriComponent
- * decodes %XX escapes bytewise (raw non-escape bytes copy through) and
- * requires the escaped bytes to form strictly valid UTF-8 (overlong
- * forms, surrogate code points, and >U+10FFFF refused, per UTF8-decode
- * without replacement); bad hex or an invalid sequence THROWS the
- * spec's URIError ("URI malformed"), catchable. Borrow; results +1. */
- | "str.encodeUriComponent" | "str.decodeUriComponent" | "str.decodeUri"
-/** RegExp.escape (ES2025): per-code-point EncodeForRegExpEscape —
- * leading ASCII alphanumeric hex-escapes, syntax characters and '/'
- * take a backslash, other punctuators/whitespace/line terminators
- * hex-escape, the rest passes through. Total; borrows; result +1. */
- | "regexp.escape"
-/** encodeURI: the same Encode() keeping the reserved set and '#'
- * unescaped — total like the component encoder. Borrow; result +1. */
- | "str.encodeUri"
-/** The WHATWG base64 globals (scr_string.c), Node-global since v16.
- * Arguments are borrowed dyn values — WebIDL ToString runs in the
- * runtime over the dyn kind (String(null) is "null": the html spec's
- * coercion, which Node's atob(null) exercises). str.atob decodes
- * forgiving-base64 (ASCII whitespace stripped, %4==0 strips up to two
- * '=', %4==1 refuses, leftover bits discarded) into the latin1 code
- * points as a string; a malformed input THROWS the catchable
- * DOMException InvalidCharacterError ("The string to be decoded is not
- * correctly encoded."). str.btoa encodes the string's code points as
- * base64; any code point over U+00FF THROWS InvalidCharacterError
- * ("Invalid character"). str.b64Missing is the zero-argument call of
- * either: always throws Node's TypeError [ERR_MISSING_ARGS] "The
- * \"input\" argument must be specified". Results +1. */
- | "str.atob" | "str.btoa" | "str.b64Missing"
-/** Number.prototype formatters (scr_lib.c), JS-exact:
- * num.toExponential is toExponential() with the spec's "as many digits
- * as necessary"; num.toFixed0 is the non-throwing omitted-argument
- * toFixed() fast path; num.toFixed implements an explicit fractionDigits
- * with exact binary-value rounding and THROWS RangeError outside 0..100.
- * Successful results +1. */
- | "num.toExponential" | "num.toFixed0" | "num.toFixed" | "num.toStringRadix"
-/** Object.is over two numbers — the spec's SameValue on doubles: NaN
- * equals NaN, +0 differs from -0, everything else is `===`. Plain bool
- * result; never throws. (Union-armed operands take unionEq's sameValue
- * flag instead — this is the both-f64 fast path.) */
- | "num.sameValue"
-/** SameValue over checked values, including NaN, signed zero and reference identity. */
- | "dyn.sameValue"
-/** `new Intl.NumberFormat("en-US").format(x)` and
- * `x.toLocaleString("en-US")` with DEFAULT options — the one locale
- * whose data the runtime embeds (Node's default-build locale): decimal
- * notation, 0–3 fraction digits rounded half-up on the SHORTEST
- * round-tripping decimal (ICU's rounding input, probed vs Node —
- * format(1.0005) is "1.001" though toFixed(3) answers "1.000"), ","
- * grouping every three integer digits, "∞"/"NaN" texts, and "-0" for
- * negative inputs rounding to zero. Result +1; never throws. */
- | "intl.numFormatEnUs"
-/** `delete process.env[NAME]` — unsetenv(3): the mutation is visible to
- * every later read (process.envGet asks getenv fresh) and inherited by
- * spawned children, exactly Node. Statement position only (JS's boolean
- * result is constant true there). Borrows the name; never throws. */
- | "process.envUnset"
-/** node:url + the URL class (scr_url.c). url.new parses one absolute
- * URL string into a mutable URL value (+1) — invalid input THROWS a
- * catchable TypeError ("Invalid URL"), like Node's constructor. The
- * getters (borrowed receiver, +1 string) never throw; url.href doubles
- * as toString(). fileURLToPath has one libFn per receiver form (URL
- * value / string) — both THROW Node's TypeErrors on non-file schemes,
- * encoded slashes, and non-empty hosts. url.pathToFileURL resolves the
- * path (getcwd) and never throws. */
- | "url.new" | "url.newBase"
-/** Factories consume already-converted input/base strings. canParse
- * answers a boolean; parse returns a checked native URL or null (+1).
- * Parser failures are suppressed; conversion occurs before these calls. */
- | "url.canParse" | "url.canParseBase" | "url.parse" | "url.parseBase" | "url.protocol" | "url.origin" | "url.username" | "url.password" | "url.host" | "url.hostname" | "url.port" | "url.pathname" | "url.href"
-/** Selected component writes borrow the receiver and converted string.
- * href replaces its parsed fields while retaining cached params identity. */
- | "url.set" | "url.setChecked" | "url.fileURLToPathUrl" | "url.fileURLToPathChecked" | "url.fileURLToPathOptions" | "url.fileURLToPathBuffer" | "url.pathToFileURLChecked" | "url.fileURLToPathStr" | "url.pathToFileURL"
-/** Explicit path syntax from the options.windows argument, independent
- * of the executable's host platform. Windows UNC input can throw. */
- | "url.pathToFileURLPlatform"
-/** pathToFileURL under a win32 TARGET: the same scr_url_from_path call
- * (the runtime selects the win32 arm by _WIN32), but a distinct IR name
- * because that arm THROWS for malformed UNC inputs — may-throw seeds on
- * it while posix pathToFileURL emission stays byte-identical. */
- | "url.pathToFileURLWin32"
-/** URLSearchParams (scr_url.c — always linked with the url unit).
- * Construction: sp.new (empty), sp.parse (one borrowed init string —
- * a single leading '?' strips, Node's constructor), sp.copy (snapshot
- * of another list), sp.fromPairs (a string[][] value — THROWS Node's
- * ERR_INVALID_TUPLE TypeError on a non-[name, value] row; the one
- * throwing entry in the family), sp.with (the record-literal init
- * desugar: append one pair, answer the same list +1 — chains fold
- * `new URLSearchParams({...})` into nested calls). url.searchParams
- * answers the URL's LIVE cached view (+1, one identity per URL);
- * url.search is the WHATWG search getter ("" for no/empty query).
- * Methods mirror the WHATWG surface: sp.get answers +1-or-NULL (the
- * sym.desc union pattern, null arm), sp.getAll a fresh string[];
- * sp.append/sp.set/sp.delete/sp.deleteValue/sp.sort mutate and
- * re-serialize a live view's URL query; sp.has/sp.hasValue answer
- * bools; sp.size/sp.toString are pure reads. sp.keyAt/sp.valAt are
- * the for-of/forEach desugar's index reads (live — the loop re-reads
- * sp.size each pass). */
- | "sp.new" | "sp.newChecked" | "sp.parse" | "sp.copy" | "sp.fromPairs" | "sp.with" | "url.searchParams" | "url.search" | "url.hash" | "sp.get" | "sp.getAll" | "sp.append" | "sp.set" | "sp.delete" | "sp.deleteValue" | "sp.has" | "sp.hasValue" | "sp.sort" | "sp.size" | "sp.toString" | "sp.keyAt" | "sp.valAt"
-/** node:querystring (scr_qs.c — link-gated by moduleUsesQs; NOT
- * URLSearchParams: the legacy codec's escaping and '+' rules differ).
- * qs.escape is Node's qsEscape, which encodes exactly the component
- * unreserved set — it emits the always-linked
- * scr_str_encode_uri_component, so escape-only programs never pull the
- * unit. qs.unescape is Node's qsUnescape: strict decodeURIComponent
- * first, the lenient legacy unescapeBuffer fallback on failure (never
- * throws). qs.parse takes (str, sep, eq, maxKeys) — the frontend
- * completes omitted/null sep/eq to "&"/"=" and the omitted maxKeys
- * option to Node's 1000 (0 and negatives mean unlimited, Node's rule) —
- * and its result type is the CALL SITE's mapped ParsedUrlQuery shape (a
- * pure index-signature record over `string | string[]`, an undefined
- * arm tolerated — @types/node's Dict), verified structurally by the
- * frontend (lowerQuerystringParseCall); the emitters construct the
- * record and hand its overflow map to scr_qs_parse_into with the two
- * union tags. qs.stringify takes (obj, sep, eq) with obj a dyn value
- * (the frontend dynFroms the typed record; JS-world dyn values pass
- * through) — Node's encodeStringified rules run in the runtime, so
- * arrays expand to repeated keys and null/undefined/nested objects are
- * empty values. Custom encoder/decoder options fence at compile time.
- * All borrow; string results +1; none throw. */
- | "qs.parse" | "qs.stringify" | "qs.escape" | "qs.unescape"
-/** node:util.parseArgs: one checked-dynamic config object in, one
- * checked-dynamic ParsedResults tree out. Statically typed member reads
- * validate their values when leaving that tree. The native parser may
- * throw Node's coded validation/grammar TypeErrors. */
- | "util.parseArgs" | "util.parseEnv" | "util.getSystemErrorName" | "util.getSystemErrorMessage" | "util.systemErrorEntries" | "util.stripVTControlCharacters" | "util.toUSVString" | "util.isDeepStrictEqual" | "util.styleText" | "util.typeIs" | "util.typeValue"
-/** ES Symbol values (scr_symbol.c — link-gated by moduleUsesSymbol).
- * sym.new: `Symbol(desc)` — a fresh runtime-unique identity (+1) whose
- * one arg is the description string (borrowed); sym.newAnon is the
- * description-less `Symbol()` form. sym.for: the Symbol.for global
- * registry — one interned symbol per key (borrowed), +1 on every call.
- * sym.toString: "Symbol(desc)" (+1 string; "Symbol()" when absent).
- * sym.desc / sym.keyFor answer the interned `string | undefined` union
- * (the runtime returns +1-or-NULL; the backend builds the union arms —
- * the child.stdout pattern). None of these throw. */
- | "sym.new" | "sym.newAnon" | "sym.for" | "sym.wellKnown" | "sym.keyFor" | "sym.desc" | "sym.toString"
-/** 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.
- * cmp returns -1/0/1 as f64; toString accepts a numeric radix. */
- | "bigint.parse" | "bigint.fromF64" | "bigint.neg" | "bigint.not" | "bigint.add" | "bigint.sub" | "bigint.mul" | "bigint.div" | "bigint.mod" | "bigint.pow" | "bigint.and" | "bigint.or" | "bigint.xor" | "bigint.shl" | "bigint.shr" | "bigint.eq" | "bigint.eqString" | "bigint.cmp" | "bigint.cmpNumber" | "bigint.truthy" | "bigint.toString" | "bigint.inspect" | "bigint.toF64" | "bigint.asUintN" | "bigint.asIntN" | "bigint.bufferRead" | "bigint.bufferWrite" | "bigint.dataViewGet" | "bigint.dataViewSet"
-/** fs.statSync → a Stats value (may throw, like the other sync fs
- * calls); the stats.* getters are pure reads on it. */
- | "fs.statSync" | "stats.isFile" | "stats.isDirectory" | "stats.size" | "stats.dev" | "stats.ino"
-/** child_process.spawnSync (scr_child.c): posix_spawn + waitpid + piped
- * utf8 capture — cmd borrowed, args one borrowed string[] (the frontend
- * completes an omitted list to an empty literal), result an owned (+1)
- * spawnRes. NEVER throws: spawn failure (nonexistent binary, EACCES) is
- * data, like Node's error property — status null and empty outputs
- * (SEMANTICS.md documents the divergence from Node's null stdout).
- * The getters are pure reads: status is the interned `number | null`
- * union (null = spawn failure or signal death, type-directed
- * construction in the backend like process.envGet); stdout/stderr are
- * +1 strings. */
- | "cp.spawnSync" | "spawnRes.status" | "spawnRes.stdout" | "spawnRes.stderr"
-/** Node's spawn-failure carrier `error?: Error`: a fresh +1 %Error
- * ("spawnSync <file> ENOENT", `code` stamped) when the spawn itself
- * failed, the interned undefined arm otherwise — the result type is the
- * call site's `Error | undefined` union, constructed type-directedly in
- * the backend (the envGet convention). Never throws. */
- | "spawnRes.error"
-/** 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.
- * 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).
- * cmd/args borrowed; result an owned (+1) child handle. The loop will
- * not exhaust while any spawned child is unreaped — Node's keep-alive.
- *
- * child.onExit / child.onClose / child.onError — terminal listener
- * registration through child.on/once. Close uses the exit adapter shape
- * but fires only after every piped stdio handle reaches EOF. The
- * receiver is borrowed, the CALLBACK MOVES into the child's listener
- * registry (released after the terminal event fires, or at reap for
- * the event that never fires). Both are void (chaining is fenced).
- * onExit's third emitted ingredient is an ADAPTER the backend interns
- * per callback shape: the runtime invokes adapter(cb, has_code, code)
- * and the adapter builds the `number | null` union (tags are program-
- * dependent) or ignores the code for a zero-param callback. onError's
- * adapters are runtime-provided (zero-param, or the %Error one-param
- * shape — scr_error_new needs no program types). "exit" fires once
- * with the code (f64 arm) or null (signal death); "error" fires only
- * for spawn failure, exactly Node's split. */
- | "cp.spawn"
-/** Static-native fork startup and IPC. process.forkTarget initializes a
- * re-executed child's inherited channel and returns its embedded target id
- * (-1 in the parent). The remaining entries mirror Node's JSON channel. */
- | "process.forkTarget" | "cp.fork" | "child.connected" | "child.send" | "child.sendCb" | "child.disconnect" | "child.onMessage" | "child.onDisconnect" | "child.onSpawn"
-/** Rest listeners use the checked function bridge to pack event arguments. */
- | "child.onDyn" | "process.connected" | "process.send" | "process.sendCb" | "process.disconnect" | "process.onMessage" | "process.onDisconnect"
-/** child_process.execFile's callback slice: starts an all-piped child,
- * captures stdout/stderr, and moves the error-first callback into the
- * child registry. The callback shape is program-dependent and checked
- * by the validator/backends. */
- | "cp.execFile" | "child.onExit" | "child.onClose" | "child.onError"
-/** The ChildProcess lifecycle members (scr_child.c), Node's shapes
- * exactly (SEMANTICS.md has the pinned matrix). child.pid is the
- * checker's `number | undefined` (undefined = spawn failure) and
- * child.exitCode its `number | null` (null while running and after a
- * signal death; -errno once a spawn failure settled) — both unions are
- * type-directed constructions in the backend over a has/get runtime
- * pair, the spawnRes.status pattern. child.killed is Node's
- * sent-a-signal flag. child.kill sends while the child is un-reaped
- * (false after — Node's null-handle answer) and THROWS the
- * Unknown-signal TypeError on bad names (may-throw); killNum passes
- * numbers through (0 probes; never throws). child.unref drops the
- * child from the loop's keep-alive set — it is still reaped while the
- * loop runs for other reasons, and one the loop never reaps is left to
- * the OS at exit. All receivers borrowed. */
- | "child.pid" | "child.exitCode" | "child.killed" | "child.kill" | "child.killNum" | "child.unref" | "child.ref"
-/** The piped-output streams (stdio mode 3 — scr_child.c's stream
- * slice). child.stdout/child.stderr answer the checker's
- * `Readable | null` union (type-directed construction in the backend
- * over the +1-or-NULL runtime pair — the child.pid pattern with a ref
- * arm). stream.onData/onEnd register 'data'/'end' listeners (receiver
- * borrowed, CALLBACK MOVES, trailing once-flag, void — chaining
- * fenced): 'data' fires one Buffer chunk per read (zero-param and
- * Buffer/string adapters are runtime-provided; setEncoding threads
- * split multibyte sequences through the shared StringDecoder core. A
- * union-param listener —
- * ngrok's `Buffer | string` — gets a compiler-emitted adapter wrapping
- * the chunk at its Buffer arm), 'end' fires once at EOF, always BEFORE
- * the child's 'exit' (the pinned ordering). A flowing stream keeps the
- * loop alive: usesTimers. */
- | "child.stdout" | "child.stderr" | "stream.onData" | "stream.onDataStr" | "stream.onEnd" | "stream.childSetEncoding"
-/** The piped-input writer (stdio mode 3 on fd 0). child.stdin answers
- * `Writable | null`; writes copy borrowed data into the nonblocking
- * queue, end/destroy settle it, writable is a pure state read, and
- * listener callbacks move into the writer registry. */
- | "child.stdin" | "writer.writeString" | "writer.writeBytes" | "writer.end" | "writer.destroy" | "writer.writable" | "writer.onDrain" | "writer.onFinish" | "writer.onError"
-/** The first-class WritableStream write (`output.write(line)` — the
- * prefixStream idiom): the receiver IS the fd scalar (process.stdout/
- * stderr reads mint 1/2), dispatched onto the exact stdoutWrite/
- * stderrWrite paths so buffering and ordering stay identical. Data
- * borrowed; the bool is Node's always-true backpressure signal. */
- | "procStream.write"
-/** node:net (scr_net.c — linked, and scr_net_install() emitted, only
- * when one of these appears on the IR; moduleUsesNet is the switch).
- * Receivers are borrowed; CALLBACKS MOVE into the handle's listener
- * registry and are released at settlement (the child.onExit story).
- * All listener registrations carry a trailing BOOL once-flag (`on` vs
- * `once`) and are void — chaining is fenced. None of these throw:
- * listen/connect failures are the async 'error' event, like Node.
- *
- * net.createServer's optional connection handler and the
- * serverOnConnection listeners take the runtime-provided adapters
- * (zero-param, or the one-param socket shape); sockOnData's adapters
- * are the stdin pair's shapes (zero-param / bytes chunk); the error
- * events reuse the child %Error adapters. net.listen/net.listenCb bind
- * NOW and defer 'listening' to the next loop turn (Node's next-tick
- * emit); net.serverPort is the composed `server.address().port` read.
- * net.connect's host argument is a string ("localhost" pins to
- * 127.0.0.1 — SEMANTICS.md); the connect callback is once('connect'). */
- | "net.createServer" | "net.createServerCb" | "net.listen" | "net.listenCb"
-/** listen({ port, host, ipv6Only }[, cb]) — the explicit-interface bind
- * (portless's listenOnProxyInterface): args [server, port, host,
- * ipv6Only]. host is an IP literal string ("" = the host-less
- * dual-stack any default); ipv6Only sets IPV6_V6ONLY before the bind.
- * These are the old-shaped calls, retained for omitted reusePort so
- * serialized IR remains compatible. Failures are the async 'error',
- * message in Node's listen shape with the requested host. Never throws. */
- | "net.listenOpts" | "net.listenOptsCb"
-/** Additive ABI for listen({ ..., reusePort }) — args
- * [server, port, host, ipv6Only, reusePort], with the callback following
- * those values in the callback form. The final BOOL is the requested
- * kernel connection-distribution option; old spellings remain
- * four/five-argument calls so serialized IR stays compatible. */
- | "net.listenOptsReusePort" | "net.listenOptsReusePortCb" | "net.serverPort" | "net.serverListening"
-/** server.address() as the full AddressInfo record (the dgram.address
- * materialization pattern: the emitter builds the record from the three
- * runtime reads; the frontend pinned the shape). Never throws — before
- * listen it answers the any-form defaults with port 0 where Node
- * answers null (the serverPort stance). */
- | "net.serverAddress" | "net.serverClose" | "net.serverCloseCb"
-/** The close-override pair (the portless close-proxy idiom).
- * serverCloseBind is `wrapper.close.bind(wrapper)` as a VALUE: a
- * compiler-emitted closure over the server whose invocation runs the
- * REAL close (scr_net_server_close_direct — never the override), so
- * the override body's `origClose(cb)` cannot recurse; its callback
- * argument (the `((err?: Error) => void) | undefined` union) registers
- * as a once-'close' listener, a one-param callback wrapped by an
- * emitted zero-arg trampoline firing the undefined arm (a clean close
- * carries no error). serverSetCloseOverride is `wrapper.close = fn`:
- * the override MOVES in behind an emitted zero-arg wrapper (it invokes
- * the user function with the undefined-arm callback — tags are program
- * data), and server.close() consults it before closing. */
- | "net.serverCloseBind" | "net.serverSetCloseOverride" | "net.serverOnError" | "net.serverOnClose" | "net.serverOnConnection"
-/** 'secureConnection' — the TLS server's deferred 'connection' list
- * (handshake-completion timing); on a server without deferred
- * connections (a plain net server) the registration never fires,
- * exactly Node's split. */
- | "net.serverOnSecureConnection" | "net.connect"
-/** connect with a validated autoSelectFamilyAttemptTimeout option (the
- * budget runs Node's validateInt32-from-1 ladder and is then inert —
- * the single dial has nothing to time). May-throw. */
- | "net.connectAttempt"
-/** net.connect/createConnection over a RUNTIME option bag (computed
- * keys — the invalid-input probes): Node-order validation (the
- * objectMode trio's ERR_INVALID_ARG_VALUE, validatePort, host string,
- * autoSelectFamily boolean, the attempt budget), then the trailing
- * compiler-rendered fence — ALWAYS THROWS (the error.nodeThrow
- * polymorphic-result carve-out). May-throw seed. */
- | "net.connectOptsChk" | "net.connectCb"
-/** connect({ port, host, autoSelectFamily: true, lookup }) — the
- * caller-resolver dial (portless's createLoopbackConnection): args
- * [port, host, lookup]. The runtime creates the (connecting) socket
- * handle, invokes the lookup as Node does — lookup(hostname, options,
- * callback), options crossing as the dyn undefined — and the answer
- * closure (an emitter-synthesized per-shape thunk over a boxed socket,
- * the SNI-answer pattern) dials the answered addresses IN ORDER: each
- * connect failure tries the next, the LAST failure's message is the
- * socket's 'error' (Node's autoSelectFamily aggregate is a documented
- * divergence), and a lookup error surfaces as the deferred socket
- * 'error'. A synchronous throw INSIDE the lookup propagates out of the
- * connect call (may-throw seed). */
- | "net.connectLookup" | "net.sockWrite" | "net.sockWriteBytes" | "net.sockEnd" | "net.sockEndStr" | "net.sockEndBytes"
-/** write/end with a CHECKED-DYNAMIC chunk (an untyped JS payload into a
- * typed socket): the runtime dispatches STR/BYTES and throws Node's
- * ERR_INVALID_ARG_TYPE chunk TypeError on any other kind. */
- | "net.sockWriteDyn" | "net.sockEndDyn" | "net.sockDestroy" | "net.sockPipe"
-/** socket.pipe(res) — raw socket chunks into a ServerResponse body
- * (the extended-CONNECT bridge leg): each chunk is a body write (the
- * response's own framing applies); source EOF end()s the response,
- * pipe's default. Borrows both. Never throws. */
- | "net.sockPipeRes" | "net.sockOnData" | "net.sockOnEnd" | "net.sockOnClose" | "net.sockOnError" | "net.sockOnConnect"
-/** node:dgram + node:dns (scr_dgram.c — linked, and
- * scr_dgram_install() emitted, only when one of these appears on the
- * IR; moduleUsesDgram is the switch — dns.lookup rides the same unit).
- * The net listener discipline verbatim: receivers borrowed, CALLBACKS
- * MOVE into the handle's registry and release at settlement, `on` vs
- * `once` is the trailing bool, registrations are void. bind/connect
- * bind NOW and defer 'listening'/'connect' to the next loop turn (the
- * net.listen story); their optional-host completions are ""
- * (bind → 0.0.0.0) and "127.0.0.1" (connect — udp4's Node default).
- * bind/connect/send/close/address THROW Node's state errors ("Socket
- * is already bound", "Already connected", "Not running") — may-throw
- * seeded. dgram.address returns the AddressInfo RECORD (the frontend
- * pins the {address, family, port} shape; the emitter builds it from
- * runtime parts). onMessage adapters are emitted per rinfo record
- * shape (the child.onExit precedent); onError reuses the child %Error
- * adapters. dns.lookup resolves via getaddrinfo AT CALL TIME and
- * defers the callback to the next turn (SEMANTICS.md documents the
- * blocking divergence); its per-union adapter builds the
- * `Error | null` first argument. */
- | "dgram.createSocket" | "dgram.bind" | "dgram.bindCb" | "dgram.connect" | "dgram.connectCb" | "dgram.sendStr" | "dgram.sendBytes"
-/** The send argument-validation ladder over dyn arguments (Node's
- * signature shuffle: slice bounds, list/type contracts, port/address
- * validation, connected-state errors) — a fully-validated unconnected
- * single-payload send RUNS; callback/list/connected forms meet the
- * trailing fence. May-throw. */
- | "dgram.sendChk" | "dgram.address" | "dgram.close" | "dgram.closeCb" | "dgram.unref" | "dgram.ref" | "dgram.onMessage" | "dgram.onError" | "dgram.onListening" | "dgram.onClose" | "dgram.onConnect" | "dns.lookup"
-/** node:test (scr_test.c — linked only when one of these appears on
- * the IR; moduleUsesNodeTest is the switch, and the main epilogue asks
- * scr_test_exit_code() for the process's exit status). Strings are
- * BORROWED, callbacks MOVE. register/suite/hook attach to the runner
- * tree (register: name, mode 0|1|2 run/skip/todo, directive message ""
- * = none, cb or absent via registerEmpty, flags 1 async | 2 takes-ctx
- * | 4 only, "file:line:col"); suite runs its body AT registration
- * (Node's collection phase). sub is t.test — runs the subtest INLINE
- * on the runner fiber and returns the settled promise the await
- * consumes. ctxSkip/ctxTodo mark the running test; ctxDiagnostic
- * queues an ℹ line; ctxName reads t.name. Every registration keeps
- * the loop-run emitted (usesTimers) so the runner fiber drains. */
- | "test.register" | "test.registerEmpty" | "test.suite" | "test.hook" | "test.sub" | "test.subEmpty" | "test.ctxSkip" | "test.ctxTodo" | "test.ctxDiagnostic" | "test.ctxName"
-/** node:http, the server slice (scr_http.c over scr_net.c — linked
- * only when these appear on the IR; moduleUsesHttpServer is the
- * switch, and any http.* libCall also counts as net use so scr_net.c
- * links and installs). http.createServer's handler MOVES in and takes
- * the runtime adapters for its (req, res) / (req) / () shapes; req
- * body listeners follow the net.sockOnData story (bytes chunks, once
- * flags); reqHeader answers the interned `string | undefined` union
- * exactly like process.envGet; the res writers are borrowed-argument
- * voids with Node's framing decided in the runtime (Content-Length
- * for end-before-head, chunked after an explicit writeHead/write). */
- | "http.createServer"
-/** http.createServer() / http.Server() with no handler — the
- * on("request") route; option helpers set parser behavior on a fresh
- * server before the constructor/factory result is returned. */
- | "http.createServerEmpty" | "http.validateHeaderName" | "http.validateHeaderValue" | "http.serverJoinDupHeaders" | "http.serverAllowMissingHostHeader"
-/** The five writable numeric http.Server timeout fields use one
- * selector ABI: 0 timeout, 1 keepAliveTimeout, 2 headersTimeout,
- * 3 requestTimeout, 4 keepAliveTimeoutBuffer. These calls store/read
- * the property values; timer enforcement remains outside this surface.
- * The constructor-option setter takes dyn so explicit undefined remains
- * distinguishable from a numeric value until its Node validation ladder. */
- | "http.serverTimeoutGet" | "http.serverSetTimeout" | "http.serverSetTimeoutCb" | "http.serverOnTimeout" | "http.serverCloseAllConnections" | "http.serverCloseIdleConnections" | "http.serverTimeoutSet" | "http.serverTimeoutOptionSet"
-/** server.on("listening", cb) — the deferred listen-callback list. */
- | "net.serverOnListening"
-/** The ServerResponse member surface: statusCode/statusMessage reads
- * and assignments (Node's writable properties), the header CRUD trio
- * (getHeader answers `string | undefined` like reqHeader), and
- * end(cb)'s finish slot (resOnFinish registers, the end call follows —
- * the callback fires deferred, Node's 'finish' emit). writeHead's
- * statusMessage forms compose in interned helpers: resStatusMsgSet
- * then the ordinary writeHead entry. */
- | "http.resStatusGet" | "http.resStatusSet" | "http.resStatusMsgGet" | "http.resStatusMsgSet" | "http.resRequest" | "http.resSocket" | "http.resWritableFinished" | "http.resSendDateGet" | "http.resSendDateSet" | "http.resStrictContentLengthGet" | "http.resStrictContentLengthSet" | "http.resSetTimeout" | "http.resSetTimeoutCb" | "http.resGetHeader" | "http.resGetHeaderNames" | "http.resGetRawHeaderNames" | "http.resGetHeaders" | "http.resHasHeader" | "http.resRemoveHeader" | "http.resOnFinish" | "http.reqUrl" | "http.reqMethod" | "http.reqHeader" | "http.reqTrailer" | "http.reqHeaderValues" | "http.reqTrailerValues" | "http.reqOnData" | "http.reqOnEnd" | "http.resSetHeader" | "http.resWriteHead" | "http.resWriteHeadN"
-/** HTTP/1.1 informational heads; early hints takes flat string pairs,
- * with a lowercase `link` key required to send anything. */
- | "http.resWriteContinue" | "http.resWriteProcessing" | "http.resWriteEarlyHints" | "http.resWrite" | "http.resWriteBytes" | "http.resEnd" | "http.resEndStr" | "http.resEndBytes"
-/** The checked-dynamic chunk twins (the net.sockWriteDyn story). */
- | "http.resWriteDyn" | "http.resEndDyn" | "http.resHeadersSent" | "http.resWritableEnded" | "http.resFlushHeaders" | "http.resAddTrailers" | "http.resCork" | "http.resUncork" | "http.resWritableCorked"
-/** The server-surface member follow-ups: reqStatusCode answers the
- * interned `number | undefined` union (negative = the undefined arm —
- * a SERVER request, where Node's statusCode is undefined; every client
- * response carries a real status); reqSocket is the underlying
- * 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
- * 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
- * shape) complete ServerResponse. sockSetTimeout arms the idle
- * EVFILT_TIMER ('timeout' fires after ms of inactivity, once per idle
- * period, never destroying the socket — Node's semantics). */
- | "http.reqStatusCode" | "http.reqSocket" | "http.reqH2Stream" | "http.reqH2StreamOrThrow" | "http.reqResume"
-/** req.rawHeaders — [name, value, name, value, ...] in arrival order,
- * names in their ORIGINAL case (Node's shape); a fresh string[] per
- * read. reqStatusMessage answers the interned `string | undefined`
- * union — the reason phrase on client responses ("" when the status
- * line carried none), the undefined arm on server requests (the
- * statusCode split). sockDestroyed is socket.destroyed — true once the
- * fd is gone (destroy() or full close). */
- | "http.reqRawHeaders" | "http.reqRawTrailers" | "http.reqStatusMessage"
-/** The `{ ...req.headers }` snapshot feed: [lowercased name, value,
- * ...] pairs in arrival order — the interned %headers.snapshot helper
- * builds the record over it, exactly the process.envPairs pattern. */
- | "http.reqHeaderPairs" | "http.reqTrailerPairs" | "net.sockDestroyed"
-/** socket.writable — the write half is open: no end() yet, no FIN sent,
- * fd alive (connecting sockets answer true; writes queue). Node's
- * stream flag. Borrows; never throws. */
- | "net.sockWritable"
-/** The 'upgrade' events, both sides (SEMANTICS.md — the WebSocket
- * proxying surface): serverOnUpgrade registers (req, socket, head)
- * listeners fired INSTEAD of 'request' for Connection: upgrade
- * requests (the parser steps aside; the socket is raw; `head` carries
- * bytes past the request head; no listener = the socket destroys,
- * Node's default). clientOnUpgrade is the client twin: a 101 response
- * fires (res, socket, head) INSTEAD of 'response'. */
- | "http.serverOnUpgrade" | "http.clientOnUpgrade"
-/** server.on("connect", ...) — HTTP CONNECT tunneling, the 'upgrade'
- * machinery's twin: (req, socket, head) fired INSTEAD of 'request' for
- * CONNECT-method requests (no listener = the socket destroys, Node's
- * default). The h2 compat server's 'connect' (portless's RFC 8441
- * handler) only ever sees the HTTP/1.1 arm under the allowHTTP1
- * lowering, so a listener whose second parameter is a UNION with a
- * netSocket arm takes the socket wrapped at that arm (an emitted
- * per-shape adapter — the tags are program data). */
- | "http.serverOnConnect"
-/** req.pipe(dest) — the IncomingMessage body streaming into a
- * ServerResponse (the proxy's response leg), a ClientRequest (the
- * request-body forward), or a raw socket (the upgrade-rejection leg);
- * chunk-for-chunk, natural end ends the destination (Node's pipe
- * default; no backpressure — divergence 54's stream model). */
- | "http.reqPipeRes" | "http.reqPipeClient" | "http.reqPipeSock" | "http.reqDestroy" | "http.reqOnError" | "http.reqOnClose" | "http.reqOnAborted" | "http.reqHttpVersion" | "http.reqHttpVersionMajor" | "http.reqHttpVersionMinor" | "http.reqAborted" | "http.reqComplete" | "http.resDestroy" | "http.resOnClose" | "http.resWriteHeadPairs"
-/** writeHead(status, headers) with a checked-dynamic headers value —
- * the runtime OBJ walk (string/number values; loud fences otherwise;
- * may throw). */
- | "http.resWriteHeadDyn" | "net.sockSetTimeout"
-/** setEncoding('utf8') — 'data' delivers strings inside the chunk-encoding window; other real encodings fence loudly, unknown names throw ERR_UNKNOWN_ENCODING (may throw). */
- | "net.sockSetEncoding" | "http.reqSetEncoding" | "net.sockOnTimeout" | "net.sockRemoteAddress"
-/** 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
- * bytes buffer instead of flowing, and EOF announces too); sockRead
- * answers `Buffer | null` (exactly n buffered bytes, or null — Node's
- * less-than-n answer; n <= 0 drains everything); sockUnshift returns
- * bytes to the front of the stream; serverEmitConnection routes a
- * socket into another server's protocol layer (a TLS target's
- * 'connection' waits for its handshake). */
- | "net.sockOnReadable" | "net.sockRead" | "net.sockUnshift"
-/** Socket flow control and the compat surface: pause/resume (reads
- * gate off/on — kernel backpressure holds paused bytes; resume flows
- * and discards sans listeners) and setNoDelay answer the SOCKET (+1,
- * Node's chaining); destroySoon ends now and destroys once the FIN
- * flushed; bytesWritten counts accepted bytes; readable is true until
- * the read half ends. */
- | "net.sockPause" | "net.sockResume" | "net.sockSetNoDelay" | "net.sockDestroySoon" | "net.sockBytesWritten" | "net.sockReadable"
-/** socket.on('finish', cb) / end(cb): fires once when the FIN goes out
- * (sweep-deferred, never the registering stack). */
- | "net.sockOnFinish" | "net.serverEmitConnection"
-/** node:http, the CLIENT slice (http.request/http.get over the net
- * client machinery): request/requestCb take (host, port, path, method,
- * timeoutMs, headerPairs, autoEnd[, responseCb]) — headerPairs is the
- * flat [k0,v0,...] array (empty for none), autoEnd true is http.get's
- * eager end(). The handle owns one dialed connection (NO pooling — the
- * wire still carries Node's exact head: user headers, then Host,
- * Connection: keep-alive, and the framing header; the socket closes
- * when the response completes). The response delivered to responseCb /
- * 'response' listeners IS an httpReq (IncomingMessage), status and
- * headers parsed from the wire, body via reqOnData/reqOnEnd. Errors are
- * Node-shaped ('connect ECONNREFUSED ip:port', 'socket hang up') and
- * fire 'error' then 'close'; an unhandled 'error' exits 1 like every
- * net handle. clientWrite before end commits to chunked framing unless
- * the caller set content-length; clientEnd(data) before any write sends
- * Content-Length exactly like Node. */
- | "http.request" | "http.requestCb"
-/** new http.Agent(opts) / new https.Agent(opts): (secure, keepAlive,
- * keepAliveMsecs, maxSockets, maxFreeSockets, timeoutMs, port) — the
- * numeric options arrive < 0 for "unset" (Infinity/256/none; port
- * seeds the settable defaultPort, Node's option merge). Returns the
- * Agent as a checked-dynamic HANDLE (getName/destroy and the
- * sockets/requests/freeSockets counters dispatch through the dyn
- * handle ops). keepAlive: true THROWS the named construction fence —
- * socket POOLING is not modeled (one dial per request); maxSockets
- * accounting is real: over-limit requests defer their dial and queue.
- * MAY THROW. */
- | "http.agentNew"
-/** The agent-threaded request rows: the http.request/https.request
- * shape with a trailing `agent` dyn argument (an Agent handle, false —
- * the one-shot Connection: close dial — or null/undefined for the
- * default path). port < 0 means "no port option": the agent's settable
- * defaultPort, then the scheme's. MAY THROW (a non-Agent value is
- * Node's ERR_INVALID_ARG_TYPE). */
- | "http.requestAgent" | "http.requestAgentCb" | "https.requestAgent" | "https.requestAgentCb"
-/** The createConnection form (the proxy's own dialer): args are
- * (connCb, path, method, timeout, headers, autoEnd[, cb]) — connCb is
- * a `() => net.Socket` closure the runtime invokes ONCE, synchronously
- * (Node's onSocket timing); everything else matches http.request. The
- * Host header defaults to "localhost" — a headers.host entry wins
- * verbatim, the proxy shape. */
- | "http.requestConn" | "http.requestConnCb"
-/** node:tls + node:https (scr_tls.c over scr_net.c/scr_http.c, with
- * the vendored mbedTLS archive — linked only when one of these appears
- * on the IR; moduleUsesTls is the switch, and every tls/https libCall
- * also counts as net AND http use so both units link and install).
- * tls.createServer takes (cert, key[, handler]) — cert/key are PEM
- * strings or Buffers (the emitter passes data+len for either); the
- * handler is Node's 'secureConnection' (fires post-handshake with a
- * socket that behaves exactly like a net socket, the same adapters as
- * net.createServer). https.createServer is (cert, key, handler) with
- * the http request-handler adapters. https.request/requestCb extend
- * the http client row with (…, rejectUnauthorized: bool, ca: PEM
- * string/Buffer — "" for none) and default port 443; everything else
- * (write/end/destroy/events, the response surface) IS the http client
- * surface — the handles are the same kinds. */
- | "tls.createServer" | "tls.createServerCb"
-/** RUNTIME options records (the divergence-66 stance): the *Dyn
- * creators take a checked-dynamic (dyn) options value whose members
- * read at runtime — cert/key extract like the literal path, members
- * whose literal forms fence THROW the catchable fence at runtime, and
- * undocumented keys drop like Node drops them. tls.pemDyn is the
- * literal walk's runtime-valued cert/key extraction: (value, whatLit)
- * → PEM bytes (strings/Buffers/one-element arrays of those) or the
- * thrown fence. All of them may throw. */
- | "tls.pemDyn" | "tls.createServerDyn" | "tls.createServerDynCb" | "https.createServerDyn" | "https.createServerDynCb"
-/** tls.connect — the TLS client socket: (port, host, opts[, cb]) where
- * port -1 reads options.port, host "" reads options.host, and opts is
- * the runtime (dyn) options record (rejectUnauthorized/ca/servername
- * implemented; other documented members throw the runtime fence). The
- * callback fires post-handshake — Node's secureConnect timing. */
- | "tls.connect" | "tls.connectCb"
-/** The TLSSocket member surface on the socket kind: authorized (bool —
- * Node's verify verdict), authorizationError (the verify-failure CODE
- * STRING or null), the 'secureConnect' registration (a TLS socket's
- * conn list fires at establishment; plain sockets never fire it), and
- * the 'session' registration (fires once with the serialized session —
- * a Buffer; the received-ticket event). */
- | "tls.sockAuthorized" | "tls.sockAuthError" | "tls.sockOnSecureConnect" | "tls.sockOnSession"
-/** tls.createSecureContext({ cert, key }) — parses the PEM pair into an
- * opaque SecureContext handle (secureCtx kind) for SNI callbacks to
- * answer with; cert/key are PEM strings or Buffers like createServer's. */
- | "tls.createSecureContext"
-/** createSecureContext over a RUNTIME options record (the checked-
- * dynamic lane): Node's typed option validations first (the ciphers/
- * passphrase/engine/version/timeout/ticketKeys ladders), then the pem
- * walk — a validated { cert, key } bag builds the real context.
- * May-throw. */
- | "tls.createSecureContextDyn"
-/** tls.getCACertificates(type): validateString + the documented name
- * set, then the trailing compiler-rendered fence — ALWAYS THROWS (the
- * error.nodeThrow polymorphic-result carve-out). May-throw seed. */
- | "tls.caCertsChk"
-/** The CA-store introspection surface (scr_tls_ca.c — its own unit and
- * link gate, "tlsca." NOT "tls.", so a getCACertificates-only binary
- * never pulls mbedTLS): tlsca.get is tls.getCACertificates(type) — the
- * cached per-type string[] of PEM blocks (identity-stable across calls,
- * Node's caching; an unknown type throws Node's ERR_INVALID_ARG_VALUE
- * TypeError); tlsca.root is the tls.rootCertificates value read;
- * tlsca.set is tls.setDefaultCACertificates(certs) — replaces the
- * default set (deduped) and the anchors the TLS client verifies
- * against, throwing Node's ERR_CRYPTO_OPERATION_FAILED when no entry
- * carries a certificate block. */
- | "tlsca.get" | "tlsca.root" | "tlsca.set" | "https.createServer" | "https.request" | "https.requestCb"
-/** The URL-string first argument, the http.requestUrl row over TLS:
- * no options means Node's defaults (verification on, default trust
- * anchors), and a non-https scheme is ERR_INVALID_PROTOCOL. */
- | "https.requestUrl" | "https.requestUrlCb"
-/** A call through a `const requestFn = tls ? https.request :
- * http.request` binding — the module-function-as-value ternary between
- * the two known clients: the https.request row with a leading `secure`
- * bool that picks the dial at RUNTIME (true = the TLS client, exactly
- * https.request; false = the plain client, exactly http.request —
- * rejectUnauthorized/ca ignored there like Node ignores TLS options on
- * http.request). The "https." prefix keeps the TLS unit linked. */
- | "https.requestFn" | "https.requestFnCb"
-/** node:http2 allowHTTP1: one TLS server advertises h2 + http/1.1 and
- * dispatches to the matching parser after ALPN. Request listeners mirror
- * into both compatibility lists; the remaining session/req.stream rows
- * below retain their explicitly limited behavior. */
- | "http2.createSecureServer"
-/** createSecureServer(options, handler) — the eager COMPAT handler as
- * the first 'request' listener (Node's exact route), on both literal
- * flavors: Req is the dual ALPN allowHTTP1 server, H2Req the ALPN=h2-only
- * server (both use compat handles over h2 streams). Args are
- * (cert, key, cb, enableConnectProtocol). */
- | "http2.createSecureServerReq" | "http2.createSecureServerH2Req"
-/** createSecureServer with a RUNTIME options record (the divergence-66
- * stance): allowHTTP1/cert/key read at runtime — allowHTTP1 picks the
- * flavor, the TLS server walk fences its out-of-bounds members with
- * the catchable runtime fence, and h2 session-tuning keys drop exactly
- * like the literal walk ignores them. May throw. The Cb form carries
- * the eager compat handler. */
- | "http2.createSecureServerDyn" | "http2.createSecureServerDynCb"
-/** createSecureServer with an SNI callback: args are (cert, key, sniCb)
- * where sniCb is the JS SNICallback — a `(servername, cb) => void`
- * closure, or the `SNICallback | undefined` union from the conditional-
- * spread spelling (`...(x ? { SNICallback: x } : {})`; the emitter
- * unwraps the union — the undefined arm means "no callback", exactly
- * the no-SNI server). The runtime parses each connection's ClientHello
- * for the server_name extension BEFORE the TLS handshake begins, calls
- * the callback with (servername, answer-closure), and resumes the
- * handshake when the answer arrives — cb(err) tears the socket down
- * silently (Node's 'tlsClientError' default), cb(null, ctx) serves
- * ctx's cert/key, cb(null, undefined) serves the default pair. */
- | "http2.createSecureServerSni"
-/** The REAL h2-over-TLS server (createSecureServer WITHOUT allowHTTP1):
- * scr_http2_create_secure_server — the h2c session machinery behind an
- * mbedTLS handshake whose ALPN advertises h2 alone (an http/1.1-only
- * client fails the handshake with no_application_protocol, Node's
- * h2-only split). args are (cert, key) — PEM strings or Buffers. */
- | "http2.createSecureServerH2" | "http.serverOnRequest" | "http2.serverOnSessionError"
-/** The guarded absent-session compatibility call remains a no-op. */
- | "http2.streamNoop"
-/** The UNGUARDED h2-only stream call (`req.stream.on(...)`): stream is
- * undefined on every connection the allowHTTP1 lowering accepts — and
- * on every HTTP/1.1 connection of Node's own allowHTTP1 server — so the
- * call IS Node's member read on undefined: throws the exact catchable
- * TypeError ("Cannot read properties of undefined (reading 'on')").
- * One arg: the read member's name (a string literal). Never returns. */
- | "http2.streamUndefCall"
-/** node:http2, the REAL h2c surface (scr_http2.c — frame codec + HPACK
- * over the net loop; the design note atop that file has the story).
- * Sessions and streams are first-class handle kinds; 'stream'/'response'
- * payloads cross as flat [name, value, ...] pairs arrays and an EMITTED
- * adapter closure builds the program-side headers record (the response
- * :status rides separately as a number). */
- | "http2.createServer" | "http2.createServerReq" | "http2.serverOnStream" | "http2.serverOnSession"
-/** connect(authority[, listener]) — h2c prior knowledge; the listener
- * closure (if any) is the 'connect' once-listener. */
- | "http2.connect" | "http2.connectCb"
-/** session.request(pairs?, endStream) — endStream is a tri-state f64:
- * -1 the method's payload-meaningless default, 0/1 explicit. */
- | "http2.sessionRequest" | "http2.sessionClose" | "http2.sessionCloseCb" | "http2.sessionDestroy" | "http2.sessionOnClose" | "http2.sessionOnError" | "http2.sessionOnConnect" | "http2.sessionOnStream" | "http2.sessionOnGoaway" | "http2.sessionSettings0" | "http2.sessionSettings" | "http2.sessionSettingsDynCb" | "http2.sessionSettingsCb0" | "http2.sessionOnSettingsDyn" | "http2.sessionOnSettings0" | "http2.sessionSettingsGet" | "http2.sessionPendingSettingsAck" | "http2.getDefaultSettings" | "http2.sessionClosed" | "http2.sessionDestroyed" | "http2.sessionEncrypted" | "http2.sessionType" | "http2.sessionAlpn" | "http2.sessionSocket"
-/** stream.respond(pairs?, endStream) — the server answer. */
- | "http2.streamRespond" | "http2.streamWrite" | "http2.streamWriteBytes" | "http2.streamEnd" | "http2.streamEndStr" | "http2.streamEndBytes" | "http2.streamClose" | "http2.streamCloseCb" | "http2.streamDestroy" | "http2.streamSetEncoding" | "http2.streamSetEncodingRet" | "http2.streamResume" | "http2.streamPause" | "http2.streamOnData" | "http2.streamOnEnd" | "http2.streamOnClose" | "http2.streamOnAborted" | "http2.streamOnError" | "http2.streamOnResponse" | "http2.streamId" | "http2.streamRstCode" | "http2.streamDestroyed" | "http2.streamClosed" | "http2.streamAborted" | "http2.streamPending" | "http2.streamSession"
-/** socket.encrypted — `boolean | undefined`: the true arm iff the
- * socket carries a TLS transport (Node types `encrypted: true` on
- * TLSSocket; plain sockets answer undefined — the proxy.ts isEncrypted
- * idiom reads it through a cast). */
- | "net.sockEncrypted" | "http.clientWrite" | "http.clientSetHeader" | "http.clientGetHeader" | "http.clientHasHeader" | "http.clientRemoveHeader" | "http.clientGetHeaderNames" | "http.clientGetRawHeaderNames" | "http.clientGetHeaders" | "http.clientWriteBytes" | "http.clientEnd" | "http.clientEndStr" | "http.clientEndBytes"
-/** The checked-dynamic chunk twins (the net.sockWriteDyn story). */
- | "http.clientWriteDyn" | "http.clientEndDyn" | "http.clientFlushHeaders" | "http.clientAddTrailers" | "http.clientCork" | "http.clientUncork" | "http.clientWritableCorked" | "http.clientMethod" | "http.clientPath" | "http.clientHost" | "http.clientProtocol" | "http.clientHeadersSent" | "http.clientWritableEnded" | "http.clientWritableFinished" | "http.clientSocket" | "http.clientReusedSocket" | "http.clientSetNoDelay" | "http.clientSetSocketKeepAlive" | "http.clientSetTimeout" | "http.clientSetTimeoutCb" | "http.statusCodes" | "http.methods" | "http.reqSetTimeout" | "http.reqSetTimeoutCb"
-/** request/get with a URL-STRING first argument: the runtime parses it
- * (WHATWG) and dials — throws catchably on an unparsable input or a
- * non-http scheme. */
- | "http.requestUrl" | "http.requestUrlCb" | "http.clientDestroy" | "http.clientAbort" | "http.clientAborted" | "http.clientDestroyed" | "http.clientOnResponse" | "http.clientOnSocket" | "http.clientOnFinish" | "http.clientOnError" | "http.clientOnTimeout" | "http.clientOnClose" | "http.clientOnAbort"
-/** fs/promises (scr_lib.c over scr_async.c's settled minting): the SAME
- * sync syscalls, wrapped in an ALREADY-SETTLED promise — failure
- * REJECTS (catchable at the await) instead of throwing, so none of
- * these are in the may-throw seed. readFile is utf8-fenced like
- * readFileSync. The non-interleaving divergence is documented in
- * SEMANTICS.md. */
-/** node:crypto randomness: randomUUID plus randomBytes as either a real
- * Buffer or the fused randomBytes(n).toString("hex"|"base64") path.
- * The size-taking forms throw Node's RangeError on invalid values. */
- | "crypto.randomUUID" | "crypto.randomBytesToString"
-/** The fused createHash(alg).update(data).digest(enc) fast path and the
- * one-shot crypto.hash implementation. First-class Hash/Hmac handles use
- * the entries below; all paths share the incremental runtime core. */
- | "crypto.hashDigestStr" | "crypto.hashDigestBytes"
-/** First-class static Hash/Hmac handles. Constructors validate the
- * runtime algorithm string (MD5, SHA-1, or SHA-2); update returns the same
- * handle by retained identity, copy snapshots Hash state, and digest
- * finalizes the handle and returns either a Buffer or encoded string. */
- | "crypto.native" | "crypto.hashNew" | "crypto.hmacNewStr" | "crypto.hmacNewBytes" | "crypto.hashUpdateStr" | "crypto.hashUpdateBytes" | "crypto.hmacUpdateStr" | "crypto.hmacUpdateBytes" | "crypto.hashCopy" | "crypto.hashDigestString" | "crypto.hashDigestBuffer" | "crypto.hmacDigestString" | "crypto.hmacDigestBuffer" | "crypto.timingSafeEqual" | "crypto.randomFill" | "crypto.randomFillRest" | "crypto.randomInt" | "crypto.pbkdf2" | "crypto.randomBytesCb" | "crypto.pbkdf2Cb" | "crypto.hkdf" | "crypto.hkdfCb" | "crypto.scrypt" | "crypto.scryptCb"
-/** crypto.randomBytes(n) → a real u8 Buffer (+1). THROWS Node's
- * RangeError on out-of-range sizes, exactly like the composed
- * randomBytesToString (which keeps its one-libCall lowering — the two
- * coexist: the composed form never materializes the Buffer). */
- | "crypto.randomBytes"
-/** The Buffer statics with fixed (always-u8) signatures. fromStr is
- * `Buffer.from(string, enc)` — the frontend completes an omitted
- * encoding to "utf8" and fences non-literal/unsupported ones; hex and
- * base64 decode Node-leniently, so it never throws. concat takes ONE
- * bytes<u8>[] arg (the list) and returns a fresh copy. `Buffer.from(u8)`
- * and `Buffer.alloc(n)` need no libFn — they lower to bytesNew. */
- | "buffer.fromStr" | "buffer.brand"
-/** Buffer.from on checked-native strings, bytes, arrays and data-only
- * array-like/Buffer-JSON objects. The encoding is a normalized literal;
- * non-string inputs ignore it. Copies the input and may throw during
- * element coercion or argument validation. Custom object valueOf and
- * opaque reference inputs retain explicit runtime refusals. */
- | "buffer.fromDyn" | "buffer.concat"
-/** Buffer.byteLength(string, enc) — enc a NORMALIZED literal like
- * fromStr's — and Buffer.isEncoding(name) over a runtime string
- * (case-insensitive against Node's alias set). Pure; never throw. */
- | "buffer.byteLenDyn" | "buffer.byteLenStr" | "buffer.isEncoding"
-/** Buffer.concat(list, totalLength): the concatenation truncated or
- * zero-padded to the total. THROWS Node's 'length' RangeError on a
- * negative/non-integer total (may-throw seed). */
- | "buffer.concatLen"
-/** The checked-dynamic compare/equals validators (scr_bytes_io.c) —
- * the lowered form when an argument is NOT statically bytes<u8> (the
- * invalid-input probes; a dyn from an untyped JS helper): Node's own
- * argument ladders run at runtime — ERR_INVALID_ARG_TYPE with the
- * API's argument name ("buf1"/"buf2", "otherBuffer", "target"; offsets
- * "of type number"), validateOffset's ERR_OUT_OF_RANGE for bad
- * numbers, undefined offsets taking their Node defaults — and a
- * well-typed value still computes the real answer. All args borrowed
- * dyn; compareChk's four offset slots pass the undefined dyn when
- * syntactically absent. May-throw seeds. */
- | "buffer.compareChk" | "bytes.equalsChk" | "bytes.compareChk"
-/** The deprecated `new Buffer(number, 'enc')` string-arm rejection:
- * always throws Node's ERR_INVALID_ARG_TYPE ("The \"string\" argument
- * must be of type string. Received ..."). Borrowed dyn; may-throw. */
- | "buffer.newStringFail"
-/** 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. */
- | "fs.toUnixTimestamp"
-/** The fs argument-validation ladders (checked-dynamic lane): each Chk
- * replicates its API's Node-order validation over dyn values (Node's
- * exact typed errors — ERR_INVALID_ARG_TYPE/VALUE, ERR_OUT_OF_RANGE),
- * and a full pass meets the trailing compiler-rendered SC2020 fence
- * string — so the ALWAYS-THROW forms take the error.nodeThrow
- * polymorphic-result carve-out. mkdtempSyncChk and the lchmod sync/
- * promise pair run the REAL operation on a validated pass instead
- * (macOS lchmod(2); non-APPLE answers Node's not-a-function /
- * ERR_METHOD_NOT_IMPLEMENTED shapes). May-throw seeds, all of them. */
- | "fs.existsChk" | "fs.mkdtempChk" | "fs.mkdtempSyncChk" | "fs.readFileChk" | "fs.opendirChk" | "fs.watchFileChk" | "fs.lchmodChk" | "fs.lchmodSyncChk" | "fsp.lchmodChk" | "fs.readChk" | "fs.streamOptsChk"
-/** The compiler-resolved ERR_INVALID_ARG_TYPE throw with a RUNTIME-
- * rendered Received tail: args [argname, "of type ..." clause, the
- * offending dyn value]. ALWAYS THROWS; polymorphic result (the
- * error.nodeThrow pattern). May-throw seed. */
- | "error.argTypeThrow"
-/** The property flavor of argTypeThrow ("The \"options.x\" property
- * must be ..."): the option-bag ladders' provably-invalid arms. ALWAYS
- * THROWS; polymorphic result. May-throw seed. */
- | "error.propTypeThrow"
-/** The checked-dynamic max-listeners ladders: setMaxChk is the
- * instance form over a dyn n (non-numbers ERR_INVALID_ARG_TYPE,
- * negatives/NaN ERR_OUT_OF_RANGE; +1 receiver back — chaining);
- * setDefaultMaxChk is the static/property form, its second argument
- * naming the message slot ("setMaxListeners" for the static call,
- * "defaultMaxListeners" for the module-property assignment). */
- | "emitter.setMaxChk" | "emitter.setDefaultMaxChk"
-/** The Buffer forms of fs: readFileSync(path) with NO
- * encoding → bytes<u8> (+1), writeFileSync/appendFileSync(path, bytes), and the
- * fs/promises readFile(path) no-encoding form (an already-settled
- * promise, rejecting on failure like the other fsp members). The sync
- * forms THROW catchably on failure exactly like the utf8 forms. */
- | "fs.readFileSyncBytes" | "fs.writeFileSyncBytes" | "fs.appendFileSyncBytes" | "fsp.readFileBytes"
-/** node:zlib (scr_zlib.c — native-toolchain.ts compiles/links it ONLY when these
- * appear on the IR, the regex/libcurl gating precedent): one-shot zlib,
- * raw-DEFLATE, gzip, and auto-detect codecs over u8 bytes with Node's
- * default options, or a validated literal compression level from -1 to 9.
- * Compression never throws (OOM aborts); decompression
- * of corrupt input THROWS Node's error catchably. */
- | "zlib.deflateSync" | "zlib.inflateSync" | "zlib.deflateRawSync"
-/** bytes, mode (0 zlib / 1 raw / 2 gzip), validated compression level. */
- | "zlib.deflateLevelSync" | "zlib.inflateRawSync" | "zlib.gzipSync" | "zlib.gunzipSync" | "zlib.unzipSync"
-/** The default-options callback twins run on the executable's shared
- * native work pool and deliver (Error | null, Buffer) on a later loop
- * turn. crc32 validates its optional uint32 seed synchronously. */
- | "zlib.deflateCb" | "zlib.inflateCb" | "zlib.deflateRawCb" | "zlib.inflateRawCb" | "zlib.gzipCb" | "zlib.gunzipCb" | "zlib.unzipCb" | "zlib.crc32"
-/** The Buffer overloads of the raw stream writes — same promptly
- * submitted streams as process.stdoutWrite/stderrWrite, constantly true.
- * The encoding arg is evaluated but ignored for bytes, like Node. The Cb
- * forms move their program-shaped completion callback to the tick queue. */
- | "process.stdoutWriteBytes" | "process.stderrWriteBytes" | "process.stdoutWriteBytesCb" | "process.stderrWriteBytesCb" | "fsp.readFile" | "fsp.writeFile"
-/** fs.promises.writeFile(path, data, { mode }): the settled-promise
- * twin of fs.writeFileModeSync. */
- | "fsp.writeFileMode" | "fsp.mkdir"
-/** The fs/promises option/member tail the certs pipeline uses: mkdir's
- * literal { recursive?, mode? } options (the mkdirSync matrix behind
- * settled promises), unlink, chmod. Failures REJECT (catchable at the
- * await), like the rest of the fsp family. */
- | "fsp.mkdirMode" | "fsp.mkdirRecursive" | "fsp.mkdirRecursiveMode" | "fsp.unlink" | "fsp.chmod" | "fsp.link" | "fsp.symlink" | "fsp.readlink" | "fsp.statfs" | "fsp.readlinkStr" | "fsp.readlinkBuffer" | "fsp.utimes" | "fsp.lutimes" | "fsp.rename" | "fsp.readdir"
-/** `fs.promises.readdir(path, { withFileTypes: true })` — the settled-
- * promise twin of fs.readdirTypesSync. The backends assemble the same
- * call-site-shaped Dirent rows, then move the array into a promise;
- * scandir failure becomes its rejection. */
- | "fsp.readdirTypes" | "fsp.rm" | "fsp.stat" | "fsp.realpath" | "fsp.lstat"
-/** fs/promises.open and the statically represented FileHandle surface.
- * Every operation returns an already-settled promise; syscall failures
- * become rejections rather than escaping synchronously. read/write
- * results are call-site record shapes ({ bytesRead/bytesWritten,
- * buffer }) assembled by the backends around the fixed runtime ABI. */
- | "fsp.open" | "fileHandle.fd" | "fileHandle.close" | "fileHandle.sync" | "fileHandle.datasync" | "fileHandle.truncate" | "fileHandle.chmod" | "fileHandle.utimes" | "fileHandle.readv" | "fileHandle.writev" | "fileHandle.read" | "fileHandle.writeBytes" | "fileHandle.writeStr" | "fileHandle.readFile" | "fileHandle.readFileBytes" | "fileHandle.writeFile" | "fileHandle.writeFileBytes" | "fileHandle.stat" | "process.argv" | "process.platform"
-/** getenv(3): one string key arg → the interned `string | undefined`
- * union (present: +1 string wrapped into the string arm; absent: the
- * interned undefined-arm instance). BOTH source forms — `process.env.FOO`
- * and `process.env[expr]` — lower here. Purely static; never throws. */
- | "process.envGet"
-/** setenv(3): (name, value) string args → void. Later envGet reads and
- * spawned children observe the write, like Node (values are strings —
- * the frontend fences non-string RHS). Never throws. */
- | "process.envSet"
-/** The whole environment as alternating [k0, v0, k1, v1, ...] strings in
- * environ order — the raw material of the process.env SNAPSHOT record
- * (the frontend's interned %env.snapshot helper keyed-writes the pairs
- * into a fresh `{ [k: string]: string | undefined }` record). Fresh +1
- * array; never throws. */
- | "process.envPairs" | "process.exit"
-/** Numeric process.exitCode write (integer validation, implicit exit status). */
- | "process.setExitCode"
-/** The code for process.exit() with no argument, or zero when unset. */
- | "process.currentExitCode" | "process.cwd"
-/** getpid(2) / getuid(2): zero args → f64. POSIX-only target, so both
- * always answer (the checker's `getuid?` optionality covers Windows —
- * `process.getuid?.()` lowers as the plain call). Never throw. */
- | "process.pid" | "process.getuid" | "process.getgid"
-/** The ambient receiver — JS `this` in a plain (non-method) function
- * body: the innermost binding the current firing/dispatch window
- * pushed (Node's listener receiver, a dyn OBJ method's object, an
- * apply/call thisArg), or the undefined dyn singleton with none bound
- * (the strict-mode plain-call answer, the old constant). Zero args →
- * dyn (+1). Never throws. */
- | "dyn.dataViewIs" | "dyn.construct" | "dyn.this" | "dyn.generatorThis"
-/** process.execPath: the compiled binary's own resolved absolute path
- * (one interned string, +1 per read) — the honest answer where Node's
- * is the node executable's (SEMANTICS.md divergence 12). Never throws. */
- | "process.execPath"
-/** process.arch: the compiled binary's OWN architecture ("arm64",
- * "x64") — Node's answer for its own build on the same machine.
- * Interned; +1 per read. Never throws. */
- | "process.arch"
-/** Stable native version dictionary. node/openssl identify compatibility
- * targets; components absent from the native runtime are omitted. */
- | "process.versions" | "process.builtinId" | "process.builtinModule" | "process.builtinUnsupported" | "fs.callbackValue" | "fs.callbackCall" | "process.hrtimeValue"
-/** process.versions.node: the runtime's Node COMPATIBILITY TARGET —
- * there is no Node under the binary, so this reports the version whose
- * semantics the runtime implements (SEMANTICS.md divergence 60, the
- * execPath stance). Interned; +1 per read. Never throws. */
- | "process.versionsNode" | "process.versionsOpenssl"
-/** umask(2): arg < 0 reads without setting (umask has no read-only form
- * — set 0, restore); otherwise sets and answers the PREVIOUS mask.
- * Never throws. */
- | "process.umask"
-/** chdir(2) — throws Node's fs-shaped error (ENOENT/EACCES/ENOTDIR,
- * syscall "chdir") on failure. */
- | "process.chdir" | "process.loadEnvFile"
-/** process._exiting: true once the exit sequence began (exit listeners
- * running) — the runtime flag scr_run_exit_listeners/process.exit set.
- * Never throws. */
- | "process.exiting"
-/** os.type(): uname(2)'s sysname ("Darwin", "Linux"; "Windows_NT" on
- * win32) — Node's uv_os_uname answer. Interned per call; never throws. */
- | "os.type"
-/** os.totalmem(): total physical memory in bytes. Never throws. */
- | "os.totalmem"
-/** net's process-wide happy-eyeballs attempt budget (Node's default
- * 250ms): one runtime double in the core unit, so reading/writing it
- * never forces the net unit into the link. Never throw. */
- | "net.getAutoSelTimeout" | "net.setAutoSelTimeout"
-/** realpath(3) with Node's error shape (syscall "lstat" in the message,
- * Node's own spelling for realpathSync failures). +1 fresh string. */
- | "fs.realpathSync"
-/** Native realpath with syscall "realpath" on failure. +1 fresh string. */
- | "fs.realpathNativeSync"
-/** kill(2) with Node's exact semantics and error shapes: the pid must be
- * an int32 (else the ERR_INVALID_ARG_TYPE TypeError text), the named
- * form resolves Node's signal-name table (unknown names throw the
- * ERR_UNKNOWN_SIGNAL TypeError), an omitted signal completes to
- * "SIGTERM" in the frontend, signal 0 probes, and a kill(2) failure
- * throws Node's `kill ESRCH`/`kill EPERM` Error. Result is Node's
- * constant true. */
- | "process.kill" | "process.killNum"
-/** execFileSync/execSync as ONE entry (args: cmd, argv, shell, input,
- * cwd, hasEnv, envPairs, timeoutMs, stdoutMode, stderrMode — see
- * scr_runtime.h). Throws Node's exact errors: "Command failed: <cmd>"
- * (+ captured stderr) on non-zero exit or signal death, "spawnSync
- * <file> ENOENT" on spawn failure, "spawnSync <file> ETIMEDOUT" after
- * the SIGTERM timeout. Result is the captured utf8 stdout (+1). */
- | "cp.execSync"
-/** The promisified-execFile capture (args: cmd, argv, cwd, hasEnv,
- * envPairs, timeoutMs): the same exec core in the async shape — both
- * streams captured, no echo, Node's ASYNC messages on the throw paths
- * ("Command failed: <cmd>\n<stderr>" with the unconditional newline,
- * "spawn <file> ENOENT" with .code, timeouts reporting as ordinary
- * SIGTERM command failures — never ETIMEDOUT). Result reuses the
- * ScrSpawnRes container (+1; stdout/stderr strings, status unused).
- * Called only from the frontend's interned %execFileAsync ASYNC helper,
- * whose fiber turns the throw into the rejection. */
- | "cp.execCapture"
-/** The raw byte writes: one borrowed string arg → bool (constantly true
- * — this synchronous runtime never queues backpressure). stdoutWrite
- * shares console.log's stream, each call is submitted promptly, and
- * interleaved output keeps source order. No newline, no formatting,
- * never throws. */
- | "process.stdoutWrite" | "process.stderrWrite" | "process.stdio" | "timers.setTimeout"
-/** 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
- * owns the callback until clearInterval removes the entry (eagerly — a
- * live interval keeps the loop alive, a cleared one releases it, like
- * Node). Neither throws; a throw ESCAPING an interval callback ends the
- * program like a setTimeout throw. */
- | "timers.setInterval" | "timers.clearInterval"
-/** setTimeout WITH a clear handle (the f64 id) — the clearable/unref-able
- * one-shot; clearTimeout cancels it, .unref() drops it from loop
- * liveness. The plain timers.setTimeout stays the handle-less
- * fire-and-forget. */
- | "timers.setTimeoutHandle" | "timers.clearTimeout"
-/** Timeout.unref()/ref()/hasRef() — loop-liveness bookkeeping over the
- * handle id. unref/ref RETURN the handle (f64) for chaining; hasRef
- * returns bool. */
- | "timers.unref" | "timers.ref" | "timers.hasRef"
-/** Timeout.refresh() — re-arm to now + the original delay (from the
- * heap or from inside the firing callback; a one-shot that fired on an
- * earlier turn is gone and no-ops — documented divergence). Returns
- * the handle for chaining like unref/ref. */
- | "timers.refresh"
-/** setImmediate/clearImmediate — Node's check phase: callbacks run
- * once per loop turn AFTER due timers, FIFO, and immediates queued
- * mid-phase wait for the next turn. setImmediate returns the f64
- * handle (its own id space — clearTimeout of an Immediate no-ops,
- * like Node); the Immediate ref trio mirrors the Timeout one (an
- * unref'd pending immediate neither keeps the loop alive nor fires
- * once nothing reffed remains). */
- | "timers.setImmediate" | "timers.clearImmediate" | "timers.immediateUnref" | "timers.immediateRef" | "timers.immediateHasRef"
-/** queueMicrotask (scr_async.c): the callback enters the SAME FIFO
- * promise continuations ride — one microtask order, like V8's queue —
- * and a throw is an UNCAUGHT exception (never a rejection).
- * timers.queueMicrotask takes an owned zero-param closure and never
- * throws; the Dyn form (checked-dynamic arguments — the mustCall
- * wrapper, the suite's invalid-input probes) throws Node's
- * ERR_INVALID_ARG_TYPE synchronously on a non-function value and calls
- * the function with zero arguments at drain. */
- | "timers.queueMicrotask" | "timers.queueMicrotaskDyn"
-/** The tolerated non-handle clear (`clearTimeout(null)`,
- * `clearInterval({})`, zero-argument forms): Node silently ignores
- * anything that is not a live handle — a VOID no-op the emitter drops
- * (only syntactically side-effect-free arguments take this path). */
- | "timers.clearNoop"
-/** process.nextTick(cb, ...args) — the user tick queue. args: [cb
- * (() => void; trailing call arguments ride the timer surface's
- * interned dyn thunk)]. Ticks drain BEFORE promise jobs at every loop
- * checkpoint, to joint exhaustion with them (Node's tick-then-
- * microtask order); ticks enqueued by station listeners run at the
- * NEXT checkpoint (the stream-tick station divergence, SEMANTICS.md).
- * Pending ticks are always-ready work — the loop neither sleeps nor
- * exits while any exist; ticks scheduled from 'exit' listeners never
- * run (Node). The enqueue itself never throws. */
- | "process.nextTick"
-/** The process introspection statics. uptime: seconds since the
- * binary's own start (fractional — a load-time monotonic anchor).
- * availableMemory/constrainedMemory: libuv's numbers (free-ish bytes;
- * the cgroup cap or 0). cpuUser/cpuSystem (+ threadCpu twins): the
- * process/thread CPU clocks in microseconds — the frontend composes
- * the {user, system} records. The *Diff forms answer current − prev
- * for one field; cpuPrevValidate throws Node's ERR_INVALID_ARG_VALUE
- * RangeError for negative/non-finite prev fields (user first, then
- * system — Node's order; MAY THROW). rusage(idx): one
- * process.resourceUsage() field by canonical index (Node's units).
- * activeResources: the loop's own bookkeeping — 'Timeout' per armed
- * (or firing, uncleared) timer, 'Immediate' per queued unfired
- * immediate; unmodeled resource kinds are absent (SEMANTICS.md). */
- | "process.uptime"
-/** perf_hooks performance.now(): fractional ms since process start. */
- | "perf.now" | "process.availableMemory" | "process.constrainedMemory" | "process.cpuUser" | "process.cpuSystem" | "process.cpuUserDiff" | "process.cpuSystemDiff" | "process.threadCpuUser" | "process.threadCpuSystem" | "process.threadCpuUserDiff" | "process.threadCpuSystemDiff" | "process.cpuPrevValidate" | "process.rusage" | "process.activeResources"
-/** Named process signal events: [name string, callback dyn, once bool]
- * or [name, callback] for removal. The runtime resolves platform signal
- * numbers and delivers (name, number). Listeners do not keep the loop
- * alive. Invalid callbacks and uncatchable signals throw. */
- | "process.onSignal" | "process.offSignal"
-/** The process 'exit' event — process.on/once/off("exit"). args: [cb,
- * once bool] / [cb]. Listeners run SYNCHRONOUSLY at termination
- * (normal exit, process.exit(), the uncaught/unhandled exit-1 paths)
- * with the exit code; anything they schedule never runs, like Node.
- * Callback shapes: () => void or (code: number) => void — the emitter
- * picks the runtime adapter. Never throw. */
- | "process.onExit" | "process.offExit"
-/** process.stdin listener registration — stdin.on/once("data" | "end" |
- * "error", cb). args: [cb, once bool]. data callbacks: () => void or
- * (chunk: Uint8Array) => void; end: () => void; error: () => void or
- * (err: Error) => void (the child error adapters are reused). While a
- * data listener (or a parked for-await chunk promise) exists, stdin
- * keeps the loop alive — Node's flowing-stdin keep-alive. Never
- * throw. */
- | "stdin.onData" | "stdin.onEnd" | "stdin.onError"
-/** 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
- * empty data chunks), which the for-await desugar turns into loop
- * exit. Never throws itself; awaiting it re-throws nothing (stdin
- * errors surface through 'error' listeners, not the iterator). */
- | "stdin.nextChunk"
-/** The runtime-provided Error hierarchy's entry points (scr_error.c).
- * error.new: one borrowed string arg (the message), result an owned (+1)
- * builtin error instance — the result TYPE names which builtin class
- * (backends derive the runtime kind from it). error.ctor: the
- * super(message) call of an `extends Error` constructor — borrowed
- * receiver (already allocated by the derived class's new) + borrowed
- * message, void; the receiver's type names the builtin class whose name
- * field to stamp. error.toString: borrowed `%Error`-typed receiver, +1
- * string in Node's "name: message" shape. Formatting can invoke a user
- * message accessor, which can throw. */
- | "error.new"
-/** ECMAScript constructors with raw checked-dynamic message/options.
- * Options retain cause presence; constructor calls borrow their args.
- * Message coercion may throw before the cause is installed. */
- | "error.newOptions" | "error.ctorOptions"
-/** Borrowed Error receiver. cause returns an owned dyn value (undefined
- * when absent); hasCause distinguishes absence from present undefined. */
- | "error.cause" | "error.hasCause"
-/** Assignment borrows both operands and retains the new cause. */
- | "error.setCause" | "error.defineCause" | "error.deleteCause"
-/** The compiler-resolved Node-parity throw for always-throwing lowered
- * arms (ERR_INVALID_THIS receivers, ERR_MISSING_ARGS arity ladders,
- * the symbol-to-string TypeError): args are [error-kind f64 (the
- * SCR_ERR_* index: 0 Error, 1 TypeError, 2 RangeError), code (empty =
- * no code slot), message]. ALWAYS THROWS catchably; the result type is
- * the replaced expression's own (never materialized — the
- * global.undefRead pattern). May-throw seed. */
- | "error.nodeThrow"
-/** JS ToString over a dyn value WITH the object protocol (a user
- * toString/valueOf member is CALLED and its throw propagates;
- * exhaustion throws "Cannot convert object to primitive value"; units
- * render "null"/"undefined") — the WHATWG USVString conversions
- * (URLSearchParams names/values). Borrowed dyn; +1 string. May-throw. */
- | "dyn.toStringCoerce" | "dyn.stringConstructor" | "dyn.propertyKey" | "dyn.toNumeric" | "dyn.increment"
-/** JS ToNumber over a dyn value WITH the object protocol (number-hint
- * valueOf/toString ordering; user throws propagate). Borrowed dyn;
- * f64 result, or a throw. Used by statically lowered numeric coercions
- * whose checker type remained any. */
- | "dyn.numberConstructor" | "dyn.bigintConstructor" | "dyn.toNumberCoerce" | "dyn.add" | "dyn.arithmetic" | "dyn.compare" | "dyn.bitwise" | "dyn.proxyNew"
-/** A read of a `declare`d const NOTHING defines (the bundler-define
- * pattern — __VERSION__): always throws the catchable ReferenceError
- * Node raises at the access ("<name> is not defined"). args[0] is the
- * name; the result type is the read's declared type (a typed dummy the
- * unwind abandons — the value never exists). */
- | "global.undefRead"
-/** A native reference to the global object; known names retain value fences. */
- | "global.native" | "console.native"
-/** `X.name` through a class VALUE (scr_object.c): args[0] is a borrowed
- * classval; the result is the class object's stored .name string,
- * retained (+1 — the string is an interned immortal, so the retain is a
- * no-op, kept for ownership uniformity). Never throws. A direct
- * `C.name` on the class name itself folds to a strLit instead. */
- | "class.name" | "error.ctor" | "error.toString" | "error.stack" | "error.stackLimitGet" | "error.stackLimitSet"
-/** `new DOMException(message?, nameOrOptions?)` (scr_error.c): both args
- * are borrowed dyn values (the lowering passes the dyn undefined for an
- * absent argument, so WebIDL's optionality lives in one place). The
- * runtime ToStrings the message ("" for absent/undefined), resolves the
- * name — absent/undefined → "Error", a non-null object → ToString of its
- * `name` member plus the `cause` own-property record, anything else →
- * ToString — and stamps the legacy code from the WebIDL name table (0
- * off-table). Result is an owned (+1) %DOMException. Never throws (dyn
- * ToString is total). */
- | "error.newDom"
-/** DOMException's own read surface (scr_error.c; %DOMException receivers
- * only — borrowed). domCode: the legacy numeric code. domHasCause: the
- * options form's own-property record (`'cause' in e`). domCause: the
- * cause value, +1 (the dyn undefined when absent — matching Node's
- * undefined read). None throws. */
- | "error.domCode" | "error.domHasCause" | "error.domCause"
-/** structuredClone of a %DOMException receiver (scr_error.c): WebIDL
- * serialization — name/message copy, the legacy code re-derives, cause
- * does not serialize. args are the borrowed receiver and the borrowed
- * options dyn value (the dyn undefined when absent — the shared
- * validation throws Node's exact option errors; any non-empty transfer
- * list throws DataCloneError, nothing static is transferable). Result
- * +1 %DOMException. */
- | "error.domClone"
-/** `d instanceof TypeError` (and the other BUILTIN error classes) on a
- * checked-dynamic value (scr_json.c): the from_error cache holds the
- * dyn↔error identity edge, so the test resolves the runtime error and
- * asks its vtable's stamped preorder interval — exact for every error
- * that crossed the boundary. A dyn object that never came from an
- * error (a hand-built {%error} literal) answers false: subclass
- * identity is unknowable there (the root keeps dynTest's marker
- * answer). args are the borrowed dyn and the SCR_ERR_* kind literal.
- * Never throws. */
- | "dyn.errInstanceof"
-/** Object.keys/values/entries over a CHECKED-DYNAMIC receiver
- * (scr_json.c): the runtime walks the dyn node's own members in JS
- * own-key order (array-index keys ascending first, then insertion
- * order) and answers a dyn array (entries: an array of [key, value]
- * pairs; values RETAIN the member nodes — reference semantics, like
- * JS). Strings/arrays/bytes answer their index keys; other scalars an
- * empty array; null/undefined throw Node's catchable TypeError
- * ("Cannot convert undefined or null to object"). */
- | "dyn.objKeys" | "dyn.forInKeys" | "dyn.hasOwn" | "dyn.propertyIsEnumerable" | "dyn.assign" | "dyn.copyDataProperties" | "dyn.objectRest"
-/** Variadic Object.assign over CHECKED-DYNAMIC targets (`Object.assign(
- * {}, ...arr.map(f), tail)` — the option-table merge): the lowering
- * builds one fresh dyn pack of sources (packPush retains a plain source
- * in; packPushSpread flattens a spread source through the spread-call
- * walk — V8's exact TypeError texts, the string arg spelling the spread
- * expression for the nullish form), so every source evaluates and
- * flattens BEFORE any copying (JS's ArgumentListEvaluation), then
- * assignAll copies each pack element's own enumerable keys onto the
- * target left to right and answers the TARGET (+1) — identity, like JS.
- * assignAll throws Node's ToObject TypeError on a nullish target. */
- | "dyn.packPush" | "dyn.packPushSpread"
-/** The iterated-path spread twin: V8 spells the optimized apply-path
- * texts (packPushSpread's — the expression named for nullish sources)
- * only for the SINGLE LAST argument's spread; any other spread position
- * drives the real iterator protocol, whose failure describes the VALUE
- * ("object null is not iterable (cannot read property
- * Symbol(Symbol.iterator))"). The frontend picks by position. */
- | "dyn.packPushSpreadIter" | "dyn.assignAll" | "dyn.reflectApply" | "dyn.reflectGet" | "dyn.reflectSet" | "dyn.reflectDefine" | "dyn.abstractEq"
-/** `Object.create(null)` (scr_json.c): a fresh NULL-PROTOTYPE dyn
- * dictionary. The checked-dynamic tree's OBJ dispatch is already own-member-only —
- * Node's null-proto answer — so the flag's whole job is the observations
- * that SEE the prototype: inspect's "[Object: null prototype]" prefix
- * and deepStrictEqual's prototype gate. Never throws. Static builds
- * only; --dynamic routes Object.create through the engine instead. */
- | "dyn.objCreateNullProto" | "dyn.arrayPrototype" | "dyn.arrayConstructor" | "dyn.objectPrototype" | "dyn.functionApply" | "dyn.builtinMethod" | "dyn.classPrototype" | "dyn.classBasePrototype" | "dyn.classInherit" | "dyn.classSuper" | "dyn.assignPrototype" | "dyn.definePrototypeProps" | "dyn.bagGet" | "dyn.bagSet" | "dyn.objCreate" | "dyn.objCreateWithProperties" | "dyn.getPrototype" | "dyn.setPrototype" | "dyn.getOwnPropertyNames" | "dyn.ownKeys" | "dyn.getOwnPropertySymbols" | "dyn.getOwnPropertyDescriptors" | "dyn.preventExtensions" | "dyn.isExtensible" | "dyn.seal" | "dyn.isSealed" | "dyn.objValues" | "dyn.objEntries"
-/** structuredClone over the checked-dynamic tree (scr_json.c): the JSON-safe subset plus
- * bytes (a fresh copy — a Buffer clones as a plain Uint8Array, like
- * Node), deep. Functions and handle kinds throw the spec's catchable
- * DataCloneError; CYCLES throw the scriptc fence (the checked-dynamic tree cannot
- * represent them — Node clones cycles; documented divergence). The
- * options dyn value validates with Node's exact errors (dictionary
- * conversion, the transfer-sequence member; any non-empty transfer
- * list throws DataCloneError). dyn.cloneMissing is the zero-argument
- * call: always throws Node's TypeError [ERR_MISSING_ARGS] with Node's
- * own (verbatim, doubly-wrapped) message. */
- | "dyn.structuredClone" | "dyn.cloneMissing"
-/** `new RegExp(pattern, flags?)` (scr_regex.c): a heap regex over the
- * same libregexp engine the literals use. The pattern compiles EAGERLY
- * so an invalid pattern (or an unknown flag letter) throws Node's
- * catchable SyntaxError at construction — Node's message shape with
- * libregexp's detail text (approximate fidelity; e.name exact). An
- * empty pattern stores the spec's "(?:)" source. Both args borrowed
- * strings (the lowering completes an absent flags to ""); result +1.
- * The result TYPE is the regex kind, so the link switch pulls the
- * engine exactly like a literal. */
- | "regex.new" | "regex.resetLastIndex" | "regex.newChecked"
-/** structuredClone with a NON-EMPTY transfer array of static values:
- * nothing static is transferable, so the call always throws Node's
- * catchable DataCloneError ("Found invalid value in transferList.") —
- * lowered directly (the list's values need no dyn representation to
- * fail). */
- | "dyn.cloneTransferFail"
-/** node:events EventEmitter (scr_events_emitter.c, link-gated by
- * moduleUsesEmitter). The receiver of every instance form is a borrowed
- * emitter-hierarchy object (`%EventEmitter` or a user subclass — the
- * backend reinterprets to ScrEmitter*, the identical prefix); event
- * names are borrowed strings (compile-time literals — the frontend
- * fences non-literals and unifies each event's argument tuple program-
- * wide). The chaining forms (on/off/removeAll/setMax) return the
- * receiver +1 typed as its static class, Node's `return this`.
- *
- * emitter.new: `new EventEmitter()` → a +1 bare emitter. emitter.ctor:
- * super() into the prefix of an emitted subclass (borrowed receiver,
- * void — allocation already initialized the prefix). emitter.on:
- * (recv, name, cb /moves/, once, prepend) — the backend synthesizes the
- * per-signature va_list invoke adapter from the cb's func type.
- * emitter.emit: (recv, name, ...tuple) — VARIADIC, the one libCall
- * whose arg count exceeds its signature; args are borrowed, result is
- * the had-listeners bool. emitter.emitError: emit('error', err) —
- * throws err when unhandled. count/countFn/names/listeners/getMax/
- * setMax/setDefaultMax/getDefaultMax are the introspection surface. */
- | "emitter.new" | "emitter.ctor" | "emitter.on" | "emitter.off" | "emitter.checkListener" | "emitter.onDyn" | "emitter.onFlex" | "emitter.offDyn" | "emitter.removeAll" | "emitter.emit" | "emitter.emitFlex" | "emitter.emitError" | "emitter.count" | "emitter.countFn" | "emitter.countDyn" | "emitter.names" | "emitter.listeners" | "emitter.setMax" | "emitter.getMax"
-/** Stream-'data' registration twins of emitter.on/onDyn (same args):
- * chosen at registration sites whose receiver is stream-rooted, so the
- * backend emits DATA thunks — the runtime's 'data' emission carries
- * BOTH payload slots (bytes, string; exactly one non-NULL — encoded
- * streams deliver strings), and the thunk unwraps the listener's
- * declared side (typed) or boxes by tag (dyn). emitter.emitData is the
- * user-emit form: (recv, name, chunk) with a bytes OR string chunk. */
- | "emitter.onData" | "emitter.onDataDyn" | "emitter.emitData" | "emitter.setDefaultMax" | "emitter.getDefaultMax"
-/** node:stream (scr_stream.c, link-gated by moduleUsesStream — which
- * implies the emitter unit: stream events dispatch through the embedded
- * ScrEmitter registry). Receivers are borrowed stream-class objects
- * (`%Readable`/`%Writable`/`%Duplex`/`%Transform`/`%PassThrough` — one
- * runtime layout, reinterpreted by side).
- *
- * Constructors (`readable.new` et al): args are [hwmR, hwmW, flags]
- * followed by the PRESENT user callbacks in canonical order (read,
- * write, final, destroy, transform, flush — the flags f64 is a bitmask
- * naming which follow; absent ones emit NULL). Every callback closure
- * MOVES and carries a leading `this` param (the stream), invoked
- * through compiler-emitted adapters. Results are +1.
- *
- * readable.push / readable.pushStr / readable.pushNull: Node's push —
- * buffers or delivers (bytes chunk borrowed; string converted utf8);
- * returns the below-hwm answer. readable.read: (recv, size — -1 for
- * absent) → Buffer|null union. pause/resume return recv +1 (`this`);
- * isPaused answers the flag. readable.pipe: (recv, dst, end) → dst +1,
- * fires 'pipe' on dst; readable.unpipe (recv[, dst]) → recv +1.
- * writable.write/writeStr: (recv, chunk[, cb]) → below-hwm bool (cb
- * MOVES when present, called after the user write completes).
- * writable.end: (recv, flags[, chunk][, cb]) → recv +1. cork/uncork are
- * void. stream.destroy/destroyErr: (recv[, err]) → recv +1.
- * stream.prop: (recv, name-literal) → the flag/number the name asks
- * for; stream.errored → Error|null union; readable.flowing →
- * bool|null union. All may leave a listener's exception pending
- * (dispatch runs user code synchronously, like emit). */
- | "readable.new" | "writable.new" | "duplex.new" | "transform.new" | "passthrough.new"
-/** Subclass initialization (`super(options?)` in a user `extends
- * Readable` constructor): same tail as the `.new` forms, prefixed with
- * the BORROWED receiver (the emitted subclass allocation — vtable and
- * display name stamped, state NULL until here). Overridden underscore
- * methods arrive as synthesized wrapper closures dispatching through
- * the vtable. Void result. */
- | "readable.init" | "writable.init" | "duplex.init" | "transform.init" | "passthrough.init"
-/** 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:
- * (optsDyn) → the fresh stream; initDyn: (recv, optsDyn, flags,
- * ...fallback wrapper closures in canonical order — the flags literal
- * names which ride, exactly the .init callback ABI). MAY THROW (a
- * consumed-but-unlowered option is the compile fence's runtime twin). */
-/** stream.finished(s, cb) — the callback form: the watcher fires once
- * at the terminal point with the finish status; the result is the +1
- * cleanup closure. stream.pipeline(count, s1..sn, cb): chains pipes,
- * propagates the first error by destroying the rest, calls cb after the
- * last 'close'; answers the destination +1. The Dyn twins take the
- * callback as a checked-dynamic VALUE (mustCall wrappers). */
- | "stream.finished" | "stream.finishedDyn" | "stream.pipeline" | "stream.pipelineDyn"
-/** node:stream/promises — the promise forms over the same machinery:
- * sp.finished: (s) → a pending void promise the terminal watcher
- * settles; sp.pipeline: (count, s1..sn) → the callback pipeline's
- * chaining/destroyer semantics settling a void promise (fulfilled on a
- * clean finish, rejected with the finish status otherwise). */
- | "sp.finished" | "sp.pipeline"
-/** 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
- * parsed dyn — malformed input rejects with the parse's SyntaxError,
- * sc.buffer: the concatenated bytes) or rejected with the stream's
- * error / ERR_STREAM_PREMATURE_CLOSE. */
- | "sc.text" | "sc.json" | "sc.buffer" | "readable.newDyn" | "writable.newDyn" | "duplex.newDyn" | "transform.newDyn" | "passthrough.newDyn" | "readable.initDyn" | "writable.initDyn" | "duplex.initDyn" | "transform.initDyn" | "passthrough.initDyn" | "readable.push" | "readable.pushStr" | "readable.pushNull" | "readable.pushU" | "readable.pushDyn" | "readable.unshift" | "readable.unshiftStr" | "readable.read" | "readable.readDyn" | "stream.onDyn" | "readable.pause" | "readable.resume" | "readable.setEncoding"
-/** push(chunk, enc) with a literal non-utf8 encoding, and the
- * defaultEncoding option's push side (how push(string) decodes —
- * Buffer.from(chunk, enc)); both carry the CANONICAL literal. */
- | "readable.pushStrEnc" | "readable.pushEncoding"
-/** for-await over a readable (the desugared loop's per-pass promise):
- * +1 promise of the next chunk — buffered content, the EOF sentinel
- * (empty Buffer / dyn undefined), or a rejection with the stream's
- * error. The Dyn twin boxes chunks by runtime tag (the JS lane).
- * readable.fromArr is Readable.from(array): a fully-seeded object-
- * entry stream (one whole chunk per element; strings per the flag). */
- | "readable.nextChunk" | "readable.nextChunkDyn" | "readable.fromArr" | "readable.isPaused" | "readable.pipe" | "readable.unpipe" | "readable.flowing" | "writable.write" | "writable.writeStr" | "writable.writeU" | "writable.writeDyn" | "writable.end" | "writable.cork" | "writable.uncork" | "stream.destroy" | "stream.destroyErr"
-/** AsyncIteratorClose for Readable[Symbol.asyncIterator](): destroy with
- * Node's AbortError/ABORT_ERR payload while the iterator's internal error
- * consumer prevents an unhandled-error crash. */
- | "stream.iteratorClose" | "stream.prop" | "stream.errored"
-/** The underscore-method assignment surface (`r._read = fn` after
- * construction — Node's own-property shadow of the prototype method):
- * args [stream receiver (borrowed), callback closure (+1 moves)]. The
- * runtime slot the matching option callback fills swaps its closure
- * and invoke thunk; the next dispatch uses it (Node's timing). The
- * setters themselves never throw. */
- | "stream.setRead" | "stream.setWrite" | "stream.setFinal" | "stream.setDestroy" | "stream.setTransform" | "stream.setFlush"
-/** NodeJS.ErrnoException's `.code` read: borrowed error-hierarchy
- * receiver → the interned `string | undefined` union (type-directed
- * construction in the backend, the process.envGet pattern) — the errno
- * name where a throw site stamped one (fs, exec spawn/timeout,
- * process.kill, the spawn 'error' event), the undefined arm everywhere
- * else. Never throws. */
- | "error.code"
-/** node:assert (scr_assert.c; assert.match in scr_regex.c — every call
- * site carries a regex value, so the regex link switch is already on).
- * Failures throw a catchable AssertionError — a runtime %Error whose
- * name is "AssertionError" and whose code slot is "ERR_ASSERTION" — so
- * `instanceof Error`, `.name`, `.message`, and `.code` all answer like
- * Node's. Generated messages are Node's assertion_error.js scalar forms
- * byte-exactly (the short `a !== b` form, the stacked `+ actual
- * - expected` diff with the string `^` indicator, the inline-vs-block
- * not-equal split); composite deep failures carry the header line
- * without the rendered inspect diff (documented divergence).
- *
- * assert.ok: (pass, message) — the frontend computed the truthiness AND
- * the full message (the user's, or the compile-time source-text form —
- * assert.fail lowers here too with pass=false). assert.eqF64/eqBigInt/
- * eqStr/eqBool: (a, b, negated, deep, msg, hasMsg) — Object.is comparison,
- * covering strictEqual/notStrictEqual and the scalar deepStrictEqual
- * pair; msg is a typed dummy ("" literal) when hasMsg is false (Node
- * distinguishes an omitted message from an empty one per operator).
- * assert.deepResult: (equal, negated, msg, hasMsg) — the verdict of a
- * frontend-synthesized structural comparison, turned into Node's throw.
- * assert.sameValue: Object.is over doubles (the deep-equal helpers'
- * number leaf; never throws). assert.match: (s, regex, negated, msg,
- * hasMsg) — a fresh exec from index 0. assert.throwsNone: (rejection,
- * ename, hasEname, msg, hasMsg) — the "Missing expected
- * exception|rejection" throw of assert.throws/rejects whose callback
- * returned (fulfilled) normally, with Node's ` (${expected.name})`
- * detail when the expected class or shape carries a name.
- * assert.throwsMismatch: (expectedName, error) — the wrong-class throw
- * of the assert.throws(fn, ErrorClass) form. assert.eqSym:
- * (a, b, negated, deep, msg, hasMsg) — strict equality over symbol
- * values, pointer identity with v24's "Symbol(desc)" stacked-diff
- * messages (scr_symbol.c, the assert.match pattern — symbol-typed
- * slots already flip the symbol link switch). assert.eqDyn:
- * (a, b, negated, deep, msg, hasMsg) — the whole quartet over
- * checked-dynamic operands (both slots dyn; the frontend boxes a
- * static side with dynFrom first): SameValue for the strict pair over
- * the dyn kinds (boxed-closure identity for functions), the structural
- * dyn walk for the deep pair, with assertion_error.js's messages —
- * scalar forms byte-exact, composites rendered compact:false/sorted
- * through the checked-dynamic tree and diffed with the real myers line printer.
- *
- * The assert.throws(fn, {name/code/message}) shape check
- * (expectedException over the static error surface): shapeBegin
- * stashes the caught error, shapeStr/shapeRe add one expected key each
- * (key ids 0 code / 1 message / 2 name; shapeRe lives in scr_regex.c —
- * its regex argument flips the regex link switch — and tests eagerly
- * so scr_assert.c stays libregexp-free), then shapeEnd throws Node's
- * deep-equal Comparison diff BYTE-EXACTLY (the bounded key set makes
- * the rendering enumerable) or the custom message.
- * assert.throwsRegex: (regex, error, msg, hasMsg) — the
- * assert.throws(fn, /re/) check over String(error), Node's
- * regex-mismatch message. assert.regexErrTest: doesNotReject's silent
- * regex predicate over String(error) (never throws).
- * assert.unwantedRejection: (error, msg, hasMsg) — doesNotReject's
- * "Got unwanted rejection" throw.
- * assert.ifErrorErr/F64/Str/Bool: assert.ifError's per-type throws
- * ("ifError got unwanted exception: " + the error's message/name or
- * the value's inspection) — the frontend routes null/undefined to a
- * no-op and everything else here (Node throws for falsy values too).
- * All arguments are borrowed. */
- | "assert.ok" | "assert.eqF64" | "assert.eqBigInt" | "assert.eqStr" | "assert.eqBool" | "assert.eqSym" | "assert.eqDyn" | "assert.looseResult" | "assert.deepResult" | "assert.sameValue" | "assert.deqEnter" | "assert.deqLeave" | "assert.match" | "assert.throwsNone" | "assert.throwsMismatch" | "assert.throwsRegex" | "assert.shapeBegin" | "assert.shapeStr" | "assert.shapeRe" | "assert.shapeEnd" | "assert.regexErrTest" | "assert.unwantedRejection" | "assert.unwantedError" | "assert.noErrorPredicate" | "assert.regexDynTest"
-/** Node's expectsError over an error-INSTANCE expected (assert.throws/
- * rejects second argument): walk the expected dyn error's keys (name,
- * message, code — the %error marker skipped) and deep-compare each
- * against the caught value's; a mismatch throws the deep-equal
- * AssertionError (scr_assert.c). MAY THROW by design. */
- | "assert.expectsErrDyn" | "assert.ifErrorErr" | "assert.ifErrorF64" | "assert.ifErrorStr" | "assert.ifErrorBool" | "assert.ifErrorDyn" | "assert.refEqBytes" | "assert.refEqFn" | "assert.bytesDeepEq"
-/** util.inspect (scr_inspect.c — its own link switch, moduleUsesInspect):
- * the runtime half of the static rendering. Scalar formatters return +1
- * strings (insp.f64: JS ToString except -0; insp.str: the quoting
- * ladder + line splitting; insp.regex: /source/flags; insp.buffer:
- * <Buffer aa ..>). insp.error renders the STACKLESS [Name: message]
- * form with the code slot as its one property. insp.dyn walks the
- * checked-dynamic tree entirely in the runtime (its shape lives in the
- * value); insp.dynS is format's %s twin (dyn strings pass verbatim).
- * insp.jsval ([value, recurse, depth], --dynamic only) renders the
- * island scalars and THROWS a catchable TypeError on composites (the
- * may-throw seed set). begin/entry/moreItems/end drive the frame
- * engine from the compiler-synthesized per-type traversal helpers
- * (%util.insp.N — the deepStrictEqual precedent). */
- | "insp.f64"
-/** util.format %j over a checked-dynamic argument: the runtime dyn
- * walk (JS-exact stringify; root undefined/function prints
- * "undefined"; a handle in the tree throws the loud fence). */
- | "insp.jsonDyn" | "insp.str" | "insp.regex" | "insp.buffer" | "insp.error" | "insp.dyn" | "insp.dynS" | "insp.jsval" | "insp.begin" | "insp.entry" | "insp.key" | "insp.moreItems" | "insp.circCheck" | "insp.seenPush" | "insp.refWrap" | "insp.circular" | "insp.end"
-/** node:string_decoder's utf8 StringDecoder (scr_string.c): the decoder
- * value is a one-field record whose f64 PACKS the pending partial
- * sequence (count + up to 3 raw bytes — Node buffers at most 3 for
- * every encoding); the frontend's interned %strdec helpers thread it,
- * with the decoder's CANONICAL encoding name first, through these pure
- * functions. write: (enc, pending, chunk) → the decoded complete
- * prefix of pending+chunk (+1); next: (enc, pending, chunk) → the
- * packed NEW pending; end: (enc, pending) → the buffered partial's
- * flush (+1). Node-exact per encoding (oracle-pinned); none throws. */
- | "strdec.write" | "strdec.next" | "strdec.end"
-/** node:readline's question/close slice (scr_readline.c, linked under
- * the events gate — these fns imply moduleUsesProcessEvents). The
- * interface value is an f64 handle (the Timeout-id precedent).
- * rl.create: [] → f64 — createInterface({ input: process.stdin,
- * output: process.stdout }), registering the unit's shared stdin
- * consumer (an OPEN interface keeps the loop alive until close/EOF,
- * Node's semantics). rl.question: [handle, query, cb] — writes the
- * query to stdout (Node writes under pipes too) and delivers the next
- * line's text through a backend-picked adapter (zero-param or
- * (answer: string)); THROWS Node's "readline was closed" on a closed
- * interface (may-throw). rl.close: [handle] — fires 'close' listeners
- * SYNCHRONOUSLY (Node's inline emit) and detaches the consumer (the
- * loop stops waiting on fd 0). rl.onClose: [handle, cb] — a zero-arg
- * listener (moves); stdin EOF closes every open interface with the
- * buffered partial line DISCARDED, like Node. */
- | "rl.create" | "rl.question" | "rl.close" | "rl.onClose"
-/** node:timers/promises — the promisified pair (scr_async.c, beside
- * the timer heap they ride): tp.setTimeout: [ms] → a pending void
- * promise a one-shot heap timer fulfills (the loop's timer phase, FIFO
- * against equal deadlines like Node); tp.setImmediate: [] → the same
- * through the immediate queue (fires before due timers of later loop
- * turns, Node's check phase). Neither throws. */
- | "tp.setTimeout" | "tp.setImmediate"
-/** node:diagnostics_channel (scr_dc.c, linked when any dc.* appears —
- * the zlib gating precedent): a process-global name→channel registry;
- * channel values are f64 handles (type-mapper.ts maps Channel to F64, the
- * readline.Interface pattern). Subscribers are dyn function values —
- * identity-compared by unsubscribe, called (message, name) by publish
- * over a SNAPSHOT of the list (a subscriber unsubscribing itself
- * mid-publish still lets its siblings fire, Node's behavior). dc.publish
- * MAY THROW: a subscriber's throw propagates out of publish (catchable
- * there) where Node routes it to triggerUncaughtException — the
- * documented divergence. subscribe/unsubscribe throw Node's
- * ERR_INVALID_ARG_TYPE TypeError for non-function subscribers. */
- | "dc.channel" | "dc.subscribe" | "dc.unsubscribe" | "dc.hasSubscribers" | "dc.publish" | "dc.chanSubscribe" | "dc.chanUnsubscribe" | "dc.chanHasSubscribers" | "dc.chanName"
-/** TracingChannel (dc.tracingChannel): a registry entry of the five
- * event channels, an f64 handle like Channel (type-mapper.ts). tcSubscribe/
- * tcUnsubscribe walk a dyn handlers object's five event keys (truthy
- * non-function slots throw the per-channel ERR_INVALID_ARG_TYPE);
- * tcTraceSync/tcTraceCallback/tcTracePromise run Node's publish choreography in C over
- * dyn values (fn, ctx, thisArg, args-array) with thisArg bound as the
- * ambient receiver — the traced call's throw and any subscriber throw
- * both propagate (MAY THROW). tcTraceCallback wraps args[position] in a
- * native error/result + asyncStart/asyncEnd publisher and throws Node's
- * TypeError when that slot is not callable. tracingChannelOf is the
- * five-Channel collection form of the constructor. */
-/** setImmediate as a first-class dyn value (scr_async.c): a minted dyn
- * callable scheduling args[0](args[1..]) on the immediate queue — the
- * Node-suite traceCallback shape (`traceCallback(setImmediate, ...)`).
- * Calling it validates the callback (the dyn call machinery); minting
- * never throws. */
- | "timers.setImmediateFnValue"
-/** `new Promise(setImmediate)` (the Node-suite early-exit shape): a
- * fresh promise an immediate fulfills with the undefined dyn value —
- * the executor IS setImmediate, so resolve rides the immediate queue
- * (scr_async.c). Never throws. */
- | "timers.immediatePromise" | "dc.tracingChannel" | "dc.tracingChannelOf" | "dc.tcChannel" | "dc.tcHasSubscribers" | "dc.tcSubscribe" | "dc.tcUnsubscribe" | "dc.tcTraceSync" | "dc.tcTraceCallback"
-/** tracePromise (scr_dc.c): start publish, the traced call, a wrap of
- * non-promise results, the end publish, and a REACTION FIBER that
- * awaits the traced promise and publishes asyncStart/asyncEnd (error
- * first on rejection) before settling the returned promise<dyn> with
- * the passed-through outcome. MAY THROW (the traced call and the
- * synchronous publishes). */
- | "dc.tcTracePromise"
-/** AsyncLocalStorage (node:async_hooks — scr_async.c): stores are f64
- * handles; contexts are immutable fiber-carried snapshots (spawned
- * fibers inherit the spawner's — Node's init-time capture). run/exit
- * enter (or clear) the store, call the dyn function with forwarded
- * arguments, and restore (the finally); getStore answers the current
- * dyn value or undefined; enterWith installs with no restore point.
- * run/exit MAY THROW (the callback's own throws propagate). */
-/** `await v` over a checked-dynamic VALUE (scr_async.c): a dyn promise
- * adopts (rejections re-throw — MAY THROW), anything else takes JS's
- * one-microtask non-thenable await and answers itself. Only emitted
- * inside async bodies (the frontend's isAsync gate). */
- | "async.awaitDyn"
-/** The bare one-microtask hop (scr_await_hop): `await v` over a typed
- * NON-promise value — JS awaits non-thenables through exactly one
- * microtask turn and yields the value itself. Never throws. */
- | "async.hop" | "als.new" | "als.get" | "als.run" | "als.exitRun" | "als.enterWith" | "als.disable"
-/** 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
- * publish and the callback (MAY THROW: transforms, subscribers, and
- * the callback all run). */
- | "dc.chanBindStore" | "dc.chanUnbindStore" | "dc.chanRunStores"
-/** process warnings (scr_lib.c): onWarning/offWarning register dyn
- * listeners; emitWarning applies Node's full argument grammar over the
- * call's dyn argument vector (ERR_INVALID_ARG_TYPE TypeErrors — MAY
- * THROW; a listener throw propagates too) and always prints Node's
- * stderr report. Emission is synchronous (SEMANTICS.md). */
- | "process.onWarning" | "process.offWarning" | "process.emitWarning"
-/** process.on/once('unhandledRejection', fn): registers a dyn listener
- * the checkpoint report dispatches per never-observed rejection —
- * (reason, promise) — instead of printing and exiting 1 (scr_async.c).
- * The bool second arg is `once` (auto-removed after one delivery,
- * Node's once); off/removeListener remove by closure identity, the
- * offWarning stance. Throws Node's ERR_INVALID_ARG_TYPE on a
- * non-function. */
-/** Uncaught exception handlers and monitors: [callback dyn, once, monitor]. */
- | "process.onUncaughtException" | "process.offUncaughtException" | "process.onUnhandledRejection" | "process.offUnhandledRejection"
-/** process.on/once/off('rejectionHandled', fn): the sibling registry.
- * A handler attached after unhandledRejection delivery fires the event
- * once. Dispatch is synchronous at the attach, with the promise,
- * Node's payload. */
- | "process.onRejectionHandled" | "process.offRejectionHandled"
-/** The Number statics with a static C implementation (scr_lib.c): one
- * f64 arg → bool, JS-exact BY CONSTRUCTION — Number.isFinite/isNaN/
- * isInteger/isSafeInteger never coerce, and the frontend routes only
- * f64-typed arguments here (other static types fence). None throws. */
- | "number.isFinite" | "number.isNaN" | "number.isInteger" | "number.isSafeInteger"
-/** Date (scr_lib.c). Values are TimeClip'd epoch-millisecond scalars:
- * construction/store/pass/getters are exact while identity and mutation
- * remain fenced. date.now is Node's integer milliseconds since epoch;
- * date.toISOString formats one raw f64 millisecond time value and
- * date.toISOStringValue formats a stored Date, both with Node's rules (UTC,
- * YYYY-MM-DDTHH:mm:ss.sssZ, expanded ±YYYYYY years outside 0–9999,
- * ToInteger truncation of fractional ms) and THROWS Node's "Invalid
- * time value" RangeError on NaN / out-of-range input (may-throw seed).
- * Results: f64 / owned (+1) string. */
- | "date.now" | "date.newNow" | "date.newMs" | "date.newString"
-/** Date.parse(dateString), with its own reach witness for exact fences. */
- | "date.parse" | "date.getTime" | "date.valueOf" | "date.toISOString" | "date.toISOStringValue" | "date.getFullYear" | "date.getUTCFullYear" | "date.getMonth" | "date.getUTCMonth" | "date.getDate" | "date.getUTCDate" | "date.getDay" | "date.getUTCDay" | "date.getHours" | "date.getUTCHours" | "date.getMinutes" | "date.getUTCMinutes" | "date.getSeconds" | "date.getUTCSeconds" | "date.getMilliseconds" | "date.getUTCMilliseconds" | "date.getTimezoneOffset"
-/** The composed `new Date(dateString).getTime()` read: one borrowed
- * string, f64 milliseconds since epoch. The parsed grammar is BOUNDED
- * (documented divergence — V8's parser accepts far more): the ASN.1
- * validity shape X509Certificate.validFrom/validTo answer ("Jul  1
- * 00:00:00 2026 GMT" — the portless cert-expiry read), and ECMA's own
- * date-time string format (YYYY-MM-DD[THH:mm[:ss[.sss]]][Z|±HH:MM] —
- * date-only forms are UTC, exactly the spec). Anything else is NaN,
- * Node's invalid-date getTime. Never throws. */
- | "date.parseGetTime"
-/** `Date.UTC(...)` — seven f64 arguments (the frontend completes the
- * spec's defaults for omitted trailing parts: month 0, date 1, time
- * parts 0), the spec's MakeDay/MakeTime/TimeClip exactly: 0–99 years
- * map to 1900+year, out-of-range months/dates roll over, non-finite
- * parts and out-of-range results answer NaN. Never throws. */
- | "date.utc"
-/** The fs option forms and friends (scr_lib.c), all throwing catchably
- * like the rest of sync fs. mkdirRecursiveSync is Node's recursive
- * algorithm (try mkdir, EEXIST-dir is fine, ENOENT creates the parent
- * first — errors report Node's errno at Node's path, EEXIST at a file
- * target, ENOTDIR at the full path past a file); the first-created-dir
- * return value has no lowering (statement position only, frontend-
- * fenced). rmOptsSync is rmSync with (recursive, force) bools: force
- * swallows ENOENT, recursive removes trees post-order, a directory
- * without recursive throws the EISDIR-worded error (divergence 13's
- * wording note). mkdtempSync appends the six X's and returns the
- * created path (+1). accessSync takes the F_OK/R_OK/W_OK/X_OK bits as
- * one f64 (the frontend bakes fs.constants.* as literals and completes
- * an omitted mode to 0). readFdSync/readFdSyncBytes are the
- * readFileSync(fd[, "utf8"]) forms — a read(2) loop to EOF on the fd
- * (the stdin path); errors carry Node's no-path message shape. */
- | "fs.mkdirRecursiveSync" | "fs.rmOptsSync"
-/** rmOptsSync's maxRetries/retryDelay form (path, recursive, force,
- * maxRetries, retryDelay): Node's linear-backoff retry on
- * EBUSY/EMFILE/ENFILE/ENOTEMPTY/EPERM — the tmpdir-harness shape
- * rmSync(p, { maxRetries: 3, recursive: true, force: true }). */
- | "fs.rmRetrySync" | "fs.mkdtempSync" | "fs.accessSync" | "fs.readFdSync" | "fs.readFdSyncBytes"
-/** isatty(3) over an fd literal (0/1/2 — process.stdin/stdout/stderr
- * .isTTY reads). A real boolean: false where Node's non-TTY streams
- * expose undefined (documented divergence). Never throws. */
- | "process.isTTY"
-/** process.stdin.destroy(): a deliberate no-op (no stream machinery
- * exists to tear down; documented in SEMANTICS.md). */
- | "process.stdinDestroy"
-/** process.stdin.setRawMode(mode) — one borrowed bool arg, void. On a
- * TTY stdin: termios raw mode on/off (libuv's UV_TTY_MODE_RAW flag set,
- * the mode Node's setRawMode(true) applies; false restores the entry
- * state). On a NON-TTY stdin Node's process.stdin has no such method at
- * all, so the call throws Node's exact catchable TypeError
- * ("process.stdin.setRawMode is not a function") — the may-throw seed
- * carries it. */
- | "process.stdinSetRawMode"
-/** Terminal width over an fd literal (1/2 — process.stdout/stderr
- * .columns): ioctl(TIOCGWINSZ). The result is the module's interned
- * `number | undefined` union — a non-TTY stream (or an ioctl refusal)
- * yields the undefined arm, exactly Node's missing `.columns`. Never
- * throws. */
- | "process.columns"
-/** Terminal height, with the same fd and optional-number contract. */
- | "process.rows"
-/** fromCharCode takes one packed f64[] or bytes arg and builds a string
- * from UTF-16 code units. Adjacent surrogate pairs combine; lone
- * surrogates follow the runtime's replacement policy. */
- | "string.fromCharCode"
-/** Numeric code points, with catchable RangeError for non-integers or
- * values outside 0..0x10ffff. Uses the same UTF-8 surrogate policy. */
- | "string.fromCodePoint"
-/** lastIndexOf returns the last UTF-16 start index, or -1. The two-arg
- * form searches at or before its numeric position; NaN starts at the end.
- * String arguments are borrowed and neither form throws. */
- | "string.lastIndexOf" | "string.lastIndexOfFrom"
-/** String.raw(template, ...subs): the raw literals array (a string[]
- * read off the template record) interleaved with the PRE-STRINGIFIED
- * substitutions (the frontend applies the static ToString and packs
- * them into one string[] literal) — extra substitutions drop, missing
- * ones skip, the spec's loop exactly (scr_array.c). Borrowed args;
- * +1 string; never throws. */
- | "string.raw"
-/** WHATWG TextDecoder.decode over u8 bytes (scr_bytes.c): utf-8 with
- * default options — the same maximal-subpart replacement decode as
- * Buffer.toString("utf8"), with the leading BOM stripped (the one
- * behavioral difference; ignoreBOM defaults to false). Inline calls
- * lower directly; stored decoder records dispatch by encoding id.
- * TextEncoder.encode needs no libFn: its matching forms
- * lower to buffer.fromStr(s, "utf8") (identical bytes — ScrStr storage
- * is well-formed UTF-8). Borrowed arg; owned (+1) string; never throws. */
- | "text.decode" | "bytes.bufferSource" | "text.decodeBufferSource" | "text.decodeOptions" | "text.decodeStream" | "text.decodeLegacyOptions"
-/** TextDecoder.decode for a compile-time non-UTF-8 WHATWG label. The
- * second f64 is the frontend-owned encoding id consumed by scr_bytes.c;
- * label aliases/case/ASCII whitespace are canonicalized before IR. The
- * mapping tables are generated from the pinned Node 24 oracle, keeping
- * output portable without an ICU/iconv dependency. Borrowed args; owned
- * (+1) string; never throws. */
- | "text.decodeLegacy" | "text.decoderEncoding" | "text.decoderName" | "text.encodeInto" | "buffer.isAscii" | "buffer.isUtf8" | "buffer.transcode"
-/** The wider sync fs slice (scr_lib.c), all throwing catchably with
- * Node's errno message shapes and `.code` stamped like the rest of
- * sync fs. unlink/chmod/chown wrap the syscalls 1:1 (Node reports the
- * syscall's own name). copyFileSync copies contents into a fresh (or
- * truncated) destination carrying the SOURCE's mode (libuv's
- * uv_fs_copyfile behavior); its errors carry BOTH paths — Node's
- * "copyfile 'src' -> 'dest'". lstatSync is statSync without following
- * a trailing symlink (Node reports lstat); stats.isSymbolicLink /
- * stats.dev / ino / blocks / nlink / atimeMs / mtimeMs / ctimeMs are pure reads on the widened
- * snapshot (blocks is allocated 512-byte units; the times are milliseconds
- * with their sub-second fractions, Node's arithmetic).
- * writeFileModeSync is writeFileSync(path, data, { mode }): the mode
- * applies at CREATION only (open(2) with O_CREAT, umask applying),
- * exactly Node — an existing file keeps its permissions. mkdirModeSync
- * / mkdirRecursiveModeSync are the mkdirSync option forms with an
- * explicit mode (the recursive walk passes it to every directory it
- * creates, like Node's). */
- | "fs.unlinkSync" | "fs.chmodSync" | "fs.chownSync" | "fs.copyFileSync"
-/** renameSync is the direct two-path syscall wrapper. renameCb defers
- * the operation to the loop and fires a program-shaped Error | null
- * callback through a backend-emitted adapter. */
- | "fs.renameSync" | "fs.renameCb" | "fs.lstatSync" | "fs.fstatSync" | "fs.fchmodSync" | "fs.fsyncSync" | "fs.fdatasyncSync" | "fs.ftruncateSync" | "fs.utimesSync" | "fs.futimesSync" | "fs.lutimesSync" | "fs.readvSync" | "fs.writevSync" | "fs.linkSync" | "fs.symlinkSync" | "fs.readlinkSync" | "fs.statfsSync" | "fs.readlinkSyncStr" | "fs.readlinkSyncBuffer"
-/** 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.
- * 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" | "fs.openNumericSync" | "fs.readSync" | "fs.writeSync" | "fs.writeStrSync" | "fs.closeSync"
-/** fs.watch(path, listener?) → an FSWatcher handle (scr_watch.c —
- * linked, and scr_watch_install() emitted, only when these appear on
- * the IR; moduleUsesFsWatch is the switch). The path opens NOW —
- * failure throws Node's fs error synchronously ("ENOENT: ..., watch
- * 'x'", the polling-fallback catch shape) — and the unit's kqueue
- * (EVFILT_VNODE) delivers "rename"/"change" through the loop's watch
- * hook. The callback (nullable) MOVES in with an adapter per listener
- * shape (zero-param, or the (eventType: string) form — runtime-
- * provided); an open watcher keeps the loop alive until watcher.close()
- * (idempotent, receiver borrowed, statement position only). */
- | "fs.watch" | "fs.watchCb" | "watcher.close"
-/** The composed `new crypto.X509Certificate(data).fingerprint` read
- * (scr_lib.c — no certificate handle exists): the SHA-1 of the DER,
- * uppercase colon-separated, over PEM or raw-DER Buffer input; other
- * inputs throw Node's ERR_OSSL_PEM_NO_START_LINE Error (may-throw). */
- | "crypto.x509Fingerprint" | "crypto.x509FingerprintStr"
-/** The certificate's Validity window (validFrom / validTo reads —
- * scr_lib.c's minimal ASN.1 walk to the TBSCertificate validity
- * SEQUENCE): UTCTime and GeneralizedTime render in Node's exact
- * ASN1_TIME_print shape ("Jul  1 00:00:00 2026 GMT" — %2d space-padded
- * day). Same input contract and PEM error as the fingerprint pair
- * (may-throw). */
- | "crypto.x509ValidFrom" | "crypto.x509ValidFromStr" | "crypto.x509ValidTo" | "crypto.x509ValidToStr" | "stats.isSymbolicLink" | "stats.blocks" | "stats.nlink" | "stats.atimeMs" | "stats.mtimeMs" | "stats.ctimeMs" | "fs.writeFileModeSync" | "fs.mkdirModeSync" | "fs.mkdirRecursiveModeSync"
-/** spawnSync with options (scr_child.c): the cp.spawnSync core plus the
- * option slice portless-class CLIs pass — timeout (killSignal fires at
- * the deadline and the result carries error: ETIMEDOUT + the signal,
- * Node's shape), killSignal (a signal NAME; "" = the SIGTERM default),
- * and per-fd stdio modes (in: 0 /dev/null, 1 ignore, 2 inherit; out/
- * err: 0 capture, 1 ignore → "", 2 inherit → ""). NEVER throws — spawn
- * failure and timeout are data on the result, like Node's error
- * property. spawnRes.signal is the result's termination signal as the
- * call site's `Signals | null` union (null = exited normally or spawn
- * failure), constructed type-directedly like spawnRes.status. */
- | "cp.spawnSyncOpts"
-/** 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
- * maps the value to the three modes. Args (cmd, argv, timeout,
- * killSignal, stdio). Never throws, like the other spawnSync forms. */
- | "cp.spawnSyncStdioStr" | "spawnRes.signal"
-/** spawn with options (scr_child.c): the cp.spawn core plus PER-SLOT
- * stdio — args are (cmd, argv, inMode, outMode, errMode, outFd, errFd,
- * detached, hasEnv, envPairs, cwd); modes 0 ignore (/dev/null), 1
- * inherit, 2 fd (out/err only — the fd dup2s into the child's slot,
- * Node's stdio fd form; the daemon-log idiom ["ignore", logFd, logFd]).
- * detached is POSIX_SPAWN_SETSID (the child gets its own session and
- * process group, Node's semantics), env is a REPLACEMENT ([k,v,...]
- * pairs like cp.execSync's), cwd ""=inherit. Same event/loop story as
- * cp.spawn. */
- | "cp.spawnOpts"
-/** Runtime options normalized into the native spawn core; unsupported
- * process features retain explicit refusals. (command, args, options). */
- | "cp.spawnDynamic"
-/** Atomics.wait(int32Array, idx, expected, timeoutMs) → "not-equal"
- * when the element differs from `expected`, else a real nanosleep for
- * the timeout and "timed-out" (scr_lib.c). scriptc has no threads —
- * no other agent can ever notify, so for every compilable program this
- * IS the spec's behavior, and "ok" is unreachable; the frontend
- * REQUIRES the timeout argument (an infinite wait here is a certain
- * deadlock, fenced). The SharedArrayBuffer the lib types demand exists
- * only syntactically (new Int32Array(new SharedArrayBuffer(n)) lowers
- * to a plain i32 typed array — sharing is unobservable without
- * threads; SEMANTICS.md documents the stance). Never throws; +1 string
- * result. */
- | "atomics.wait";
 /** Numeric binary ops. The bitwise six (`&`/`|`/`^`/`<<`/`>>`/`>>>`) have
  * JS ToInt32/ToUint32 semantics — operands convert (NaN/±Infinity → 0,
  * truncate, wrap mod 2^32), the operation runs in 32-bit space (shift
@@ -5259,258 +3373,3 @@ export declare function canMarshalIntoIsland(t: IrType, getRecord: (shapeId: str
  * Promise.all arm). Null = outside the domain (the boundary fence). */
 export declare function islandPromisePayloadTag(inner: IrType): "void" | "f64" | "bool" | "string" | "jsval" | "jsvalArr" | null;
 export declare function canExitIslandToType(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
-export interface RuntimeFeatures {
-    regex: boolean;
-    copying: boolean;
-    legacyTextDecoder: boolean;
-    fileHandle: boolean;
-    fetch: boolean;
-    processEvents: boolean;
-    emitter: boolean;
-    stream: boolean;
-    zlib: boolean;
-    dc: boolean;
-    assert: boolean;
-    dynInvoke: boolean;
-    dynAsync: boolean;
-    inspect: boolean;
-    childProcess: boolean;
-    net: boolean;
-    symbol: boolean;
-    bigint: boolean;
-    searchParams: boolean;
-    qs: boolean;
-    parseArgs: boolean;
-    fsWatch: boolean;
-    nodeTest: boolean;
-    dgram: boolean;
-    http: boolean;
-    http2: boolean;
-    tls: boolean;
-    tlsCa: boolean;
-}
-/** Inspect types and expressions together in one traversal. This is a fresh
- * snapshot: callers may mutate an IR module between compilation passes. */
-export declare function moduleRuntimeFeatures(mod: IrModule): RuntimeFeatures;
-/** True when the module contains any regex construct — a regexLit /
- * regexIntrinsic node or a regex-typed slot anywhere. This is the link
- * switch that pulls scr_regex.c + the vendored libregexp into the binary
- * (native-toolchain.ts); regex-free programs keep the historical command line. The
- * typed traversal visits type slots as well as executable nodes. */
-export declare function moduleUsesRegex(mod: IrModule): boolean;
-/** True when the module contains an intrinsic whose implementation lives
- * in scr_copying.c. This is the link switch that keeps the optional
- * Array-copying and typed-array bridge TU out of unrelated binaries. */
-export declare function moduleUsesCopying(mod: IrModule): boolean;
-/** True when a non-UTF-8 TextDecoder call survives lowering. This gates the
- * generated legacy mapping tables inside scr_bytes.c; the default UTF-8
- * decoder and unrelated Buffer users keep their prior runtime object. */
-export declare function moduleUsesLegacyTextDecoder(mod: IrModule): boolean;
-/** True when a FileHandle type survives in the module. This is the link
- * switch for scr_file_handle.c; fs/promises.open carries the type inside its
- * promise result even when no handle method is called. */
-export declare function moduleUsesFileHandle(mod: IrModule): boolean;
-/** True when user code lowers static fetch or the embedded npm graph
- * reaches the engine's global fetch — the link switch that pulls scr_fetch.c +
- * its socket/tls/zlib dependencies into the binary (native-toolchain.ts) and has the
- * emitted main call scr_fetch_install. The npm graph records the embedded
- * source fact with a parser + binder, so comments, strings, property names,
- * and local `fetch` bindings do not change the link or target capability.
- * Fetch-free graphs keep their exact historical link lines. */
-export declare function moduleUsesFetch(mod: IrModule): boolean;
-/** True when the module uses the process-events surface — the link switch
- * that pulls scr_events.c into the binary and has the emitted main call
- * scr_events_install (native-toolchain.ts + emitter; the scr_regex/scr_fetch/scr_zlib
- * gating precedent). Event-free programs pay zero bytes and keep their
- * exact link line. Same generic-walk shape as moduleUsesRegex. */
-export declare function moduleUsesProcessEvents(mod: IrModule): boolean;
-/** True when the module uses the node:events EventEmitter surface — the
- * link switch that pulls scr_events_emitter.c into the binary (native-toolchain.ts; the
- * scr_events.c gating precedent, but pure data structure: no install, no
- * loop hooks). Two signals: the `%EventEmitter` class def rides the
- * module (any emitter-typed value or `extends EventEmitter` subclass
- * references it, and the emitted RC/trace helpers call scr_emitter_*),
- * or an emitter.* libCall survived (the defaultMaxListeners statics carry
- * no emitter-typed value). Emitter-free programs pay zero bytes and keep
- * their exact link line. */
-export declare function moduleUsesEmitter(mod: IrModule): boolean;
-/** True when the program touches the node:stream surface (scr_stream.c —
- * the moduleUsesEmitter story: the class defs ride the module whenever a
- * stream-typed value exists, and every stream libCall names its unit).
- * Stream programs always use the emitter unit too — the stream class
- * defs pull `%EventEmitter` through their base chain, so
- * moduleUsesEmitter answers true whenever this does. Stream-free
- * programs pay zero bytes and keep their exact link line. */
-export declare function moduleUsesStream(mod: IrModule): boolean;
-/** True when the embedded npm graph has an edge into `builtin` — the
- * island shim needs the corresponding native bridge linked (zlib's is
- * the first; the emitted main installs it before any island entry). */
-export declare function moduleEmbedsBuiltin(mod: IrModule, builtin: string): boolean;
-/** Embedded module texts at least this long are DEFLATE-compressed into
- * the emitted LLVM (island.ts; each stays plain when deflate does not
- * shrink it) and inflated lazily by the island's module loader at first
- * load. Below it the zlib round trip cannot pay for itself. */
-export declare const NPM_COMPRESS_MIN = 1024;
-/** True when the emitted npm tables will carry compressed module text —
- * the SAME candidate test island.ts compresses by, so index.ts's
- * zlib link switch and emitter.ts's inflater installation stay in
- * lockstep with the emission (a candidate whose deflate happens not to
- * shrink stays plain; the installed inflater is then just unused). */
-export declare function moduleEmbedsCompressedNpm(mod: IrModule): boolean;
-/** True when the module contains any zlib libCall (the static lowering)
- * OR the embedded npm graph imports node:zlib (the island shim) — the
- * link switch that pulls scr_zlib.c + the system libz into the binary
- * (native-toolchain.ts); zlib-free programs keep their exact link line. Same
- * generic-walk shape as moduleUsesRegex: `kind`/`fn` discriminants live
- * only on IR objects. */
-export declare function moduleUsesZlib(mod: IrModule): boolean;
-/** True when the module contains any dc.* libCall — the link switch that
- * pulls scr_dc.c (the diagnostics_channel registry and pub/sub) into the
- * binary (native-toolchain.ts). Channel-free binaries keep their exact size class.
- * Same walk shape as moduleUsesZlib. */
-export declare function moduleUsesDc(mod: IrModule): boolean;
-/** True when the module contains any assert libCall — the link switch
- * that pulls scr_assert.c into the binary (native-toolchain.ts). scr_regex.c calls the
- * assert throw/inspect helpers (assert.match lives there), so the regex
- * switch also pulls scr_assert.c; assert-free, regex-free binaries keep
- * the historical command line and size. Same walk shape as
- * moduleUsesZlib. */
-export declare function moduleUsesAssert(mod: IrModule): boolean;
-/** True when the module contains any dynInvoke node or dyn.defineProps
- * libCall — the link switch that pulls scr_dyn_invoke.c (the prototype-
- * method dispatch on dyn receivers, plus scr_dyn_display and
- * scr_dyn_define_props) into the binary (native-toolchain.ts; the assert gating
- * precedent — dispatch-free binaries keep their exact size class). Same
- * walk shape as moduleUsesZlib. */
-export declare function moduleUsesDynInvoke(mod: IrModule): boolean;
-/** True when the module contains any insp libCall — the link switch that
- * pulls scr_inspect.c into the binary (native-toolchain.ts; the assert gating
- * precedent — inspect-free binaries keep the historical command line and
- * size class). Same walk shape as moduleUsesZlib. */
-/** True when the module needs scr_async_dyn.c — the checked-dynamic
- * async surfaces (dyn-promise then/catch/finally reactions, await of a
- * dyn value, `new Promise(setImmediate)`, AsyncLocalStorage, the
- * unhandledRejection/warning process events). Also pulled by the
- * dynInvoke and dc gates (their TUs call into this one) — native-toolchain.ts. Same
- * walk shape as moduleUsesZlib. */
-export declare function moduleUsesDynAsync(mod: IrModule): boolean;
-export declare function moduleUsesInspect(mod: IrModule): boolean;
-/** True when the module reaches child_process or carries one of its runtime
- * handle/result types. Besides the existing link consequence, this gates the
- * checked-dynamic ChildProcess handle table installed from scr_child.c. */
-export declare function moduleUsesChildProcess(mod: IrModule): boolean;
-/** True when the module contains any net libCall — the link switch that
- * pulls scr_net.c into the binary and has the emitted main call
- * scr_net_install (native-toolchain.ts + emitter; the scr_events gating precedent).
- * Net-free programs pay zero bytes and keep their exact link line. Same
- * generic-walk shape as moduleUsesZlib. */
-export declare function moduleUsesNet(mod: IrModule): boolean;
-/** True when the module contains any sym.* libCall or a symbol-kind type
- * anywhere in the IR — the link switch that pulls scr_symbol.c into the
- * binary (native-toolchain.ts; the scr_net gating precedent — no install call, the
- * Symbol.for registry initializes lazily). The TYPE check matters like
- * net's: a symbol-typed local whose initializer compiled to a runtime
- * fence still emits release calls that need the unit linked. Symbol-free
- * programs pay zero bytes and keep their exact link line. */
-export declare function moduleUsesSymbol(mod: IrModule): boolean;
-/** True when bigint runtime operations or bigint-typed storage appears in
- * the IR. The type check keeps retain/release references link-safe even
- * when a producing statement was replaced by a runtime fence. */
-export declare function moduleUsesBigInt(mod: IrModule): boolean;
-/** True when the module uses the URLSearchParams surface — sp.* libCalls,
- * the url.searchParams getter, or a searchParams-kind type anywhere on
- * the IR (a fenced statement can leave a typed local whose release call
- * still needs the unit linked) — the link switch that pulls
- * scr_url_params.c into the binary (the moduleUsesSymbol precedent: pure
- * data structure, no loop hooks, cross-compiles everywhere). sp-free
- * programs keep their exact link line; scr_url.c itself stays
- * always-linked and never references the unit. */
-export declare function moduleUsesSearchParams(mod: IrModule): boolean;
-/** True when the module uses the node:querystring surface — the qs.*
- * libCalls that live in scr_qs.c (parse/stringify/unescape; qs.escape
- * emits the always-linked component encoder and deliberately does NOT
- * flip this switch) — the link switch that pulls scr_qs.c into the
- * binary (the moduleUsesSearchParams precedent: pure data transforms, no
- * loop hooks, cross-compiles everywhere). qs-free programs keep their
- * exact link line. Same generic-walk shape as moduleUsesZlib. */
-export declare function moduleUsesQs(mod: IrModule): boolean;
-/** True when the module uses native util parsing, comparison, or styling.
- * The utility units also follow their required symbol, inspection, and
- * warning features, independently of the island's node:util shim. */
-export declare function moduleUsesParseArgs(mod: IrModule): boolean;
-/** True when the module contains any fs.watch/watcher.* libCall — the
- * link switch that pulls scr_watch.c into the binary and has the emitted
- * main call scr_watch_install (native-toolchain.ts + emitter; the scr_net gating
- * precedent). Watch-free programs pay zero bytes and keep their exact
- * link line. Same generic-walk shape as moduleUsesZlib. */
-export declare function moduleUsesFsWatch(mod: IrModule): boolean;
-/** True when the module contains any test.* libCall or a testCtx handle
- * type — the link switch that pulls scr_test.c into the binary and has
- * the emitted main return scr_test_exit_code() after the loop drains
- * (native-toolchain.ts + emitter; the moduleUsesDgram shape). Test-free programs pay
- * zero bytes and keep their exact link line. */
-export declare function moduleUsesNodeTest(mod: IrModule): boolean;
-/** True when the module contains any dgram.* or dns.* libCall — the
- * link switch that pulls scr_dgram.c into the binary and has the emitted
- * main call scr_dgram_install (native-toolchain.ts + emitter; the scr_net gating
- * precedent — dns.lookup lives in the same unit, so either prefix
- * answers). Dgram-free programs pay zero bytes and keep their exact link
- * line. Same generic-walk shape as moduleUsesZlib. */
-export declare function moduleUsesDgram(mod: IrModule): boolean;
-/** True when the module contains any http.* libCall — the link switch
- * that pulls scr_http.c into the binary (native-toolchain.ts; moduleUsesNet already
- * answers true for these, so scr_net.c comes along). */
-export declare function moduleUsesHttpServer(mod: IrModule): boolean;
-/** True when the module uses the REAL h2 surface (scr_http2.c): any core
- * http2.* libCall, or an h2 handle type left behind by a fenced statement
- * (its emitted release call needs the unit — the moduleUsesNet story). */
-export declare function moduleUsesHttp2(mod: IrModule): boolean;
-/** True when the module contains any tls.* or https.* libCall — the link
- * switch that pulls scr_tls.c and the vendored mbedTLS archive into the
- * binary (native-toolchain.ts; moduleUsesNet and moduleUsesHttpServer already answer
- * true for these, so scr_net.c and scr_http.c come along). TLS-free
- * programs keep their exact link line and never build mbedTLS. */
-export declare function moduleUsesTls(mod: IrModule): boolean;
-/** True when the module contains any tlsca.* libCall — the link switch
- * for scr_tls_ca.c, the CA-store introspection unit (getCACertificates /
- * rootCertificates / setDefaultCACertificates). Deliberately SEPARATE
- * from moduleUsesTls: the unit is plain PEM-block bookkeeping, so a
- * program that only inspects the CA store never pulls mbedTLS. native-toolchain.ts
- * also compiles the unit whenever TLS itself links — scr_tls.c consults
- * the unit's default-set override for its trust anchors. */
-export declare function moduleUsesTlsCa(mod: IrModule): boolean;
-/** First async/event-loop/ambient-process surface the module graph
- * reaches, or null when the graph is async_free (the v1 library requirement).
- * Typed slots use their declaration location and executable nodes use their
- * own location, so the refusal anchors at the reaching construct; the
- * coarse moduleUses* predicates are the safety net behind the fine-grained
- * table (a surface reached only through a spelling the table misses still
- * refuses, anchored at the entry). */
-export declare function moduleLibAsyncSurface(mod: IrModule): {
-    surface: string;
-    loc: SrcLoc;
-} | null;
-/** libCall families that demote `deterministic` (prefix match over
- * IrLibFn spellings). process.stdout/stderr writes are deliberately NOT
- * here: output is an effect, not a nondeterminism input, and console
- * policy is the profile's ask-5 business. process.platform/arch and the
- * version constants fold at compile time, so they are per-binary
- * constants, not ambient reads. Exported for the attestation-parity test
- * (tests/harness/surface-manifest.test.ts): every spelling this table
- * demotes on must be deniable by a manifest-id fence, or the ask-5 §4
- * invariant (compiles under full fences ⇒ deterministic) cannot be
- * stated. */
-export declare const LIB_NONDETERMINISTIC_PREFIXES: readonly [string, string][];
-/** First ambient-nondeterminism or ambient-authority surface the module
- * graph reaches, or null when the graph is clean (the sidecar then
- * attests `deterministic: true`). */
-export declare function moduleLibNondeterministicSurface(mod: IrModule): string | null;
-/** The may-throw seed: libCall members that can raise. Every fs.* member
- * EXCEPT existsSync (which, like Node's, swallows errors and returns false)
- * throws a catchable error on failure; json.parse throws a catchable
- * SyntaxError-shaped string on malformed input. Backends' may-throw analyses must treat a function containing one
- * of these as throwing, exactly like a `throw` statement (and must ALSO
- * seed on `dynCheck` and `awaitExpr` nodes, which throw on validation
- * failure / promise rejection). */
-export declare const MAY_THROW_LIB_FNS: ReadonlySet<IrLibFn>;
-export {};