@scriptc/compiler 0.1.2 → 0.1.3

package/dist/ir/ir.d.ts

@@ -12,6 +12,14 @@ export type IrBytesElem = "u8" | "u32" | "i32" | "f32";
 export type IrType = {
     kind: "f64";
 }
+/** An ECMAScript bigint primitive. Runtime values are immutable,
+ * arbitrary-precision signed integers (ScrBigInt) whose numeric value,
+ * not pointer identity, defines equality. The heap representation is an
+ * implementation detail: bigint remains a JS primitive for truthiness,
+ * typeof, comparison, inspection, and container semantics. */
+ | {
+    kind: "bigint";
+}
 /** The supported ES Date value slice: a scalar TimeClip'd millisecond
  * value. Getters and toISOString observe only this slot, so copying it
  * through locals/params/fields is exact while Date mutation and object
@@ -216,6 +224,13 @@ export type IrType = {
  | {
     kind: "childStream";
 }
+/** A piped child-input stream (child.stdin — spawn with a piped stdin
+ * slot; scr_child.c). Heap, refcounted, and mutable: writes queue into
+ * the platform pipe without blocking the JavaScript thread, and
+ * drain/finish/error listeners drop when the writer settles. */
+ | {
+    kind: "childWriter";
+}
 /** A process output stream as a FIRST-CLASS value (process.stdout /
  * process.stderr flowing into a `NodeJS.WritableStream` slot — the
  * prefixStream idiom). Representation is the raw FD as a double (1 or
@@ -245,6 +260,16 @@ export type IrType = {
  | {
     kind: "secureCtx";
 }
+/** A node:crypto Hash or Hmac handle (scr_lib.c): heap, refcounted,
+ * MUTABLE until digest(), then permanently finalized. The two TypeScript
+ * surfaces share one runtime representation but stay distinct IR kinds so
+ * Hash.copy() cannot accidentally appear on Hmac values. The incremental
+ * digest state owns no script values and cannot participate in a cycle. */
+ | {
+    kind: "cryptoHash";
+} | {
+    kind: "cryptoHmac";
+}
 /** Heap, refcounted closure. `rest` marks a VARIADIC JS function (a
  * `...args` rest parameter, or a zero-param function body reading
  * `arguments` — test/common's mustCall wrapper): the lifted function
@@ -388,13 +413,13 @@ 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", "fsWatcher", "childStream", "procStream"];
+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 declare const HANDLE_KINDS: IrKindSet<"child" | "childStream" | "dgramSocket" | "fileHandle" | "fsWatcher" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "netServer" | "netSocket" | "procStream" | "secureCtx" | "spawnRes" | "stats" | "testCtx">;
+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 both native backends. */
-declare const POINTER_KIND_LIST: readonly ["string", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "fsWatcher", "childStream", "func", "object", "classval", "record", "union", "dyn", "jsval", "caught", "promise", "generator"];
+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", "record", "union", "dyn", "jsval", "caught", "promise", "generator"];
 export type PointerKind = typeof POINTER_KIND_LIST[number];
-export declare const POINTER_KINDS: IrKindSet<"array" | "bytes" | "caught" | "child" | "childStream" | "classval" | "dgramSocket" | "dyn" | "fileHandle" | "fsWatcher" | "func" | "generator" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "jsval" | "map" | "netServer" | "netSocket" | "object" | "promise" | "record" | "regex" | "searchParams" | "secureCtx" | "set" | "spawnRes" | "stats" | "string" | "symbol" | "testCtx" | "union" | "url">;
+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" | "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).
  * Keeping this exhaustive makes a new runtime handle kind a compile error
@@ -409,6 +434,7 @@ export declare function runtimeRcStem(t: IrType): string | null;
  * arms with `true`. */
 export declare const REF_TRUTHY_KINDS: ReadonlySet<string>;
 export declare const F64: IrType;
+export declare const BIGINT_T: IrType;
 export declare const DATE_T: IrType;
 export declare const BYTES_U8: IrType;
 export declare const STRING: IrType;
@@ -431,8 +457,11 @@ export declare const HTTPREQ_T: IrType;
 export declare const HTTPRES_T: IrType;
 export declare const HTTPCLIENTREQ_T: IrType;
 export declare const SECURECTX_T: IrType;
+export declare const CRYPTOHASH_T: IrType;
+export declare const CRYPTOHMAC_T: IrType;
 export declare const FSWATCHER_T: IrType;
 export declare const CHILDSTREAM_T: IrType;
+export declare const CHILDWRITER_T: IrType;
 export declare const PROCSTREAM_T: IrType;
 export declare const VOID: IrType;
 export declare const DYN: IrType;
@@ -520,7 +549,7 @@ export declare function typeEquals(a: IrType, b: IrType): boolean;
 export declare function isRefCounted(t: IrType): boolean;
 export interface IrModule {
     /** Bumped on any breaking IR change; serialize.ts refuses mismatches. */
-    irVersion: 8;
+    irVersion: 9;
     sourceFile: string;
     functions: IrFunction[];
     /** Class shapes. Constructors and methods are ordinary module functions
@@ -1815,6 +1844,11 @@ export type IrLibFn =
  * (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.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.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"
@@ -1836,10 +1870,9 @@ export type IrLibFn =
  * the backend (the envGet convention). Never throws. */
  | "spawnRes.error"
 /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawnp
- * with stdio "ignore" (all three fds on /dev/null — the only supported
- * stdio; "pipe"/"inherit" are frontend-fenced), the child registered
- * with the event loop, which polls waitpid(WNOHANG) at quiescence like
- * timers (kqueue is the follow-up; SEMANTICS.md documents the polling).
+ * 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).
@@ -1887,6 +1920,11 @@ export type IrLibFn =
  * the child's 'exit' (the pinned ordering). A flowing stream keeps the
  * loop alive: usesTimers. */
  | "child.stdout" | "child.stderr" | "stream.onData" | "stream.onEnd"
+/** 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/
@@ -2329,18 +2367,19 @@ export type IrLibFn =
  * these are in the may-throw seed. readFile is utf8-fenced like
  * readFileSync. The non-interleaving divergence is documented in
  * SEMANTICS.md. */
-/** node:crypto, the string-producing slice: randomUUID (never throws)
- * and the COMPOSED randomBytes(n).toString("hex"|"base64") — one
- * libCall, the Buffer never escapes (bare randomBytes is fenced).
- * randomBytesToString THROWS Node's RangeError on out-of-range sizes. */
+/** 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 COMPOSED hash chain createHash(alg).update(data).digest(enc)
- * fused into one call — the Hash handle never materializes. Args are
- * (alg, data, enc); alg is "sha256" | "sha1" and enc "hex" | "base64",
- * both compile-time literals (frontend-fenced). Strings hash their
- * UTF-8 bytes (Node's default input encoding); the bytes form hashes a
- * Buffer/typed array's bytes. Pure; never throw. */
+/** 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/sha1/sha256); 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.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.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
@@ -2894,8 +2933,8 @@ export type IrLibFn =
  *
  * 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/eqStr/
- * eqBool: (a, b, negated, deep, msg, hasMsg) — Object.is comparison,
+ * 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).
@@ -2941,7 +2980,7 @@ export type IrLibFn =
  * 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.eqStr" | "assert.eqBool" | "assert.eqSym" | "assert.eqDyn" | "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.ok" | "assert.eqF64" | "assert.eqBigInt" | "assert.eqStr" | "assert.eqBool" | "assert.eqSym" | "assert.eqDyn" | "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"
 /** 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
@@ -3400,8 +3439,8 @@ export type IrExpr =
     type: IrType;
     loc: SrcLoc;
 }
-/** JS ToBoolean: f64 is false iff 0, -0, or NaN; string is false iff empty.
- * Operand is f64|string (bool needs no conversion) or a UNION — the ARM
+/** JS ToBoolean: f64 is false iff 0, -0, or NaN; string is false iff empty;
+ * dyn asks its runtime kind. The other operand form is a UNION — the ARM
  * value's ToBoolean via a per-union interned helper (unit arms false;
  * f64/string/bool arms per-value; ref arms — arrays, records, objects,
  * functions, maps, sets, promises, ... — always true; jsval arms ask the
@@ -5124,6 +5163,10 @@ export declare function moduleUsesNet(mod: IrModule): boolean;
  * 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

package/dist/ir/ir.js

@@ -14,8 +14,11 @@ const POINTER_HANDLE_KINDS = [
     "httpRes",
     "httpClientReq",
     "secureCtx",
+    "cryptoHash",
+    "cryptoHmac",
     "fsWatcher",
     "childStream",
+    "childWriter",
 ];
 function irKindSet(kinds) {
     return new Set(kinds);
@@ -30,6 +33,7 @@ export const HANDLE_KINDS = irKindSet(HANDLE_KIND_LIST);
 /** The IR kinds represented as pointers in both native backends. */
 const POINTER_KIND_LIST = [
     "string",
+    "bigint",
     "array",
     "map",
     "set",
@@ -57,6 +61,7 @@ export const POINTER_KINDS = irKindSet(POINTER_KIND_LIST);
  * until its one retain/release family is named here. */
 export const RUNTIME_RC_STEMS = {
     f64: "",
+    bigint: "scr_bigint",
     date: "",
     string: "scr_str",
     bool: "",
@@ -82,9 +87,12 @@ export const RUNTIME_RC_STEMS = {
     httpRes: "scr_http_res",
     httpClientReq: "scr_http_client",
     childStream: "scr_child_stream",
+    childWriter: "scr_child_writer",
     procStream: "",
     fsWatcher: "scr_watcher",
     secureCtx: "scr_secure_ctx",
+    cryptoHash: "scr_crypto_hash",
+    cryptoHmac: "scr_crypto_hash",
     func: "scr_closure",
     object: "",
     classval: "scr_classobj",
@@ -124,13 +132,14 @@ export const REF_TRUTHY_KINDS = new Set([
     "symbol",
     "date", "array", "map", "set", "regex", "url", "searchParams", "stats", "fileHandle", "spawnRes", "child",
     "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq",
-    "secureCtx", "fsWatcher", "childStream", "procStream", "bytes", "func", "object", "record", "promise",
+    "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "procStream", "bytes", "func", "object", "record", "promise",
     // A generator object is a JS object: always truthy.
     "generator",
     // A class object is a JS object (constructors are functions): always truthy.
     "classval",
 ]);
 export const F64 = { kind: "f64" };
+export const BIGINT_T = { kind: "bigint" };
 export const DATE_T = { kind: "date" };
 export const BYTES_U8 = { kind: "bytes", elem: "u8" };
 export const STRING = { kind: "string" };
@@ -153,8 +162,11 @@ export const HTTPREQ_T = { kind: "httpReq" };
 export const HTTPRES_T = { kind: "httpRes" };
 export const HTTPCLIENTREQ_T = { kind: "httpClientReq" };
 export const SECURECTX_T = { kind: "secureCtx" };
+export const CRYPTOHASH_T = { kind: "cryptoHash" };
+export const CRYPTOHMAC_T = { kind: "cryptoHmac" };
 export const FSWATCHER_T = { kind: "fsWatcher" };
 export const CHILDSTREAM_T = { kind: "childStream" };
+export const CHILDWRITER_T = { kind: "childWriter" };
 export const PROCSTREAM_T = { kind: "procStream" };
 export const VOID = { kind: "void" };
 export const DYN = { kind: "dyn" };
@@ -177,6 +189,7 @@ export function isUnitType(t) {
 export function isSupportedArrayElem(t) {
     switch (t.kind) {
         case "f64":
+        case "bigint":
         case "bool":
         case "string":
         case "array":
@@ -239,6 +252,7 @@ export function isSupportedSetElem(t) {
 export function isSupportedMapValue(t) {
     switch (t.kind) {
         case "f64":
+        case "bigint":
         case "string":
         case "bool":
         case "record":
@@ -329,6 +343,7 @@ export function typeKey(t) {
         return t.kind;
     switch (t.kind) {
         case "f64":
+        case "bigint":
         case "date":
         case "string":
         case "bool":
@@ -746,6 +761,7 @@ function isJsonSafeAt(t, getRecord, getUnion, stringify, undefinedAllowed, visit
         // Symbols are DROPPED by Node's stringify (undefined at the top level,
         // omitted as object values) — silent divergence banned; rejected.
         case "symbol":
+        case "bigint":
         // Typed arrays stringify as index-keyed objects ({"0":1,...}) and
         // Buffers as {type:"Buffer",data:[...]} in Node — neither shape is
         // representable type-directedly; rejected like Maps.
@@ -1630,11 +1646,11 @@ export function moduleUsesChildProcess(mod) {
         const node = v;
         if (node.kind === "libCall" &&
             typeof node.fn === "string" &&
-            (node.fn.startsWith("cp.") || node.fn.startsWith("child.") || node.fn.startsWith("spawnRes."))) {
+            (node.fn.startsWith("cp.") || node.fn.startsWith("child.") || node.fn.startsWith("writer.") || node.fn.startsWith("spawnRes."))) {
             found = true;
             return;
         }
-        if (node.kind === "child" || node.kind === "childStream" || node.kind === "spawnRes") {
+        if (node.kind === "child" || node.kind === "childStream" || node.kind === "childWriter" || node.kind === "spawnRes") {
             found = true;
             return;
         }
@@ -1719,6 +1735,31 @@ export function moduleUsesSymbol(mod) {
     visit(mod);
     return found;
 }
+/** 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 function moduleUsesBigInt(mod) {
+    let found = false;
+    const visit = (v) => {
+        if (found || v === null || typeof v !== "object")
+            return;
+        if (Array.isArray(v)) {
+            for (const item of v)
+                visit(item);
+            return;
+        }
+        const node = v;
+        if (node.kind === "bigint" ||
+            (node.kind === "libCall" && typeof node.fn === "string" && node.fn.startsWith("bigint."))) {
+            found = true;
+            return;
+        }
+        for (const key of Object.keys(v))
+            visit(v[key]);
+    };
+    visit(mod);
+    return found;
+}
 /** 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
@@ -2103,6 +2144,7 @@ const LIB_MODE_REFUSED_KINDS = new Map([
     ["child", "the child_process surface"],
     ["spawnRes", "the child_process surface"],
     ["childStream", "the child_process surface"],
+    ["childWriter", "the child_process surface"],
     ["netServer", "the node:net surface"],
     ["netSocket", "the node:net surface"],
     ["http2Session", "the node:http2 surface"],
@@ -2281,6 +2323,20 @@ export function moduleLibNondeterministicSurface(mod) {
  * seed on `dynCheck` and `awaitExpr` nodes, which throw on validation
  * failure / promise rejection). */
 export const MAY_THROW_LIB_FNS = new Set([
+    "bigint.parse",
+    "bigint.fromF64",
+    "bigint.div",
+    "bigint.mod",
+    "bigint.pow",
+    "bigint.shl",
+    "bigint.shr",
+    "bigint.toString",
+    "bigint.asUintN",
+    "bigint.asIntN",
+    "bigint.bufferRead",
+    "bigint.bufferWrite",
+    "bigint.dataViewGet",
+    "bigint.dataViewSet",
     "fetch.responseNew",
     "fetch.abortTimeout",
     "fetch.abortAny",
@@ -2555,6 +2611,27 @@ export const MAY_THROW_LIB_FNS = new Set([
     "fs.statSync",
     "crypto.randomBytesToString",
     "crypto.randomBytes",
+    "crypto.hashDigestStr",
+    "crypto.hashDigestBytes",
+    "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",
     "buffer.concat",
     "buffer.concatLen",
     // The checked-dynamic compare/equals validators: Node's argument
@@ -2612,6 +2689,7 @@ export const MAY_THROW_LIB_FNS = new Set([
     // catchable AssertionError on failure.
     "assert.ok",
     "assert.eqF64",
+    "assert.eqBigInt",
     "assert.eqStr",
     "assert.eqBool",
     "assert.eqSym",