@scriptc/compiler 0.2.0 → 0.2.2

package/dist/ir/ir.js

@@ -959,7 +959,7 @@ export function canMarshalTypedFuncIntoIsland(t, getRecord, getUnion) {
  * through a dyn value), properties ON function values, and params/results
  * outside the conversion domains (Maps, class instances, ...). Promises
  * CONVERT in (canConvertToDyn's promise arm — an async dyn-boxed closure's
- * return) but do not check OUT (`u as Promise<T>` stays fenced).
+ * return); checking OUT preserves the boxed Promise<unknown> payload ABI.
  */
 /** The runtime HANDLE kinds that cross the checked-dynamic boundary as
  * the checked-dynamic tree's HANDLE kind (SCR_DYN_HANDLE): boxed by REFERENCE (identity —
@@ -1016,7 +1016,7 @@ export function classDynViewSupported(fields, getRecord, getUnion) {
  * JSON-safe data, numeric typed arrays (retained views), identity-preserving class
  * references, undefined-armed unions of those arms, boxable function types,
  * and the runtime HANDLE kinds (boxed by reference — DYN_HANDLE_KINDS). */
-export function canConvertToDyn(t, getRecord, getUnion) {
+export function canConvertToDyn(t, getRecord, getUnion, visiting = new Set()) {
     if (isJsonSafeType(t, getRecord, getUnion))
         return true;
     // numeric typed arrays and boxable functions are dyn kinds the walker boxes
@@ -1024,14 +1024,14 @@ export function canConvertToDyn(t, getRecord, getUnion) {
     // in records/arrays/unions. isJsonSafeType rejects them, but dynFrom
     // needs only that the walker can build the dyn value, so this composite
     // fold extends the JSON-safe core.
-    if (canBoxDynComposite(t, getRecord, getUnion))
+    if (canBoxDynComposite(t, getRecord, getUnion, visiting))
         return true;
     if (t.kind === "bytes")
         return true;
-    // %Error converts as the checked-dynamic tree's error encoding ({%error, name, message,
+    // Built-in errors convert as the checked-dynamic tree's error encoding ({%error, name, message,
     // code?} — the caughtToDyn shape, scr_dyn_from_error): the dyn 'error'
     // listener boundary (a mustCall-wrapped handler receiving the payload).
-    if (t.kind === "object" && t.className === "%Error")
+    if (t.kind === "object" && RUNTIME_ERROR_CLASSES.has(t.className))
         return true;
     if (isDynTypedRefType(t))
         return true;
@@ -1040,7 +1040,7 @@ export function canConvertToDyn(t, getRecord, getUnion) {
     if (t.kind === "classval")
         return true;
     if (t.kind === "func")
-        return canBoxFuncIntoDyn(t, getRecord, getUnion);
+        return canBoxFuncIntoDyn(t, getRecord, getUnion, visiting);
     if (DYN_HANDLE_KINDS.has(t.kind))
         return true;
     // Promises box by REFERENCE (SCR_DYN_PROMISE): promise<dyn> carries its
@@ -1052,7 +1052,7 @@ export function canConvertToDyn(t, getRecord, getUnion) {
     if (t.kind === "promise") {
         return (t.inner.kind === "dyn" ||
             t.inner.kind === "void" ||
-            canConvertToDyn(t.inner, getRecord, getUnion));
+            canConvertToDyn(t.inner, getRecord, getUnion, visiting));
     }
     if (t.kind === "union") {
         const def = getUnion(t.unionId);
@@ -1062,18 +1062,29 @@ export function canConvertToDyn(t, getRecord, getUnion) {
         // boundary exactly like a bare func dynFrom).
         return !!def && def.arms.every((a) => a.kind === "undefinedT" || isJsonSafeType(a, getRecord, getUnion) ||
             isDynTypedRefType(a) || a.kind === "classval" || DYN_HANDLE_KINDS.has(a.kind) ||
-            (a.kind === "func" && canBoxFuncIntoDyn(a, getRecord, getUnion)) ||
-            (a.kind === "promise" && canConvertToDyn(a, getRecord, getUnion)));
+            (a.kind === "func" && canBoxFuncIntoDyn(a, getRecord, getUnion, visiting)) ||
+            (a.kind === "promise" && canConvertToDyn(a, getRecord, getUnion, visiting)));
     }
     return false;
 }
 /** The composite extension of the dynFrom domain: JSON-safe scalars plus
  * numeric typed arrays and boxable functions anywhere, recursing through records
  * (fields + index value), arrays, and unit-armed unions — exactly the
- * sc_td_* walker's capability. Returns false for a composite carrying a
- * kind the walker cannot box (Maps or handles nested in a record); those
- * still fence. */
+ * sc_td_* walker's capability. Map and Set payloads must also support
+ * checked extraction back into native storage. Other unsupported nested
+ * kinds retain their conversion fence. */
 function canBoxDynComposite(t, getRecord, getUnion, visiting = new Set()) {
+    const key = `boxed:${typeKey(t)}`;
+    if (visiting.has(key))
+        return true;
+    const result = canBoxDynCompositeAt(t, getRecord, getUnion, visiting);
+    if (result)
+        visiting.add(key);
+    else
+        clearDynConversionResults(visiting);
+    return result;
+}
+function canBoxDynCompositeAt(t, getRecord, getUnion, visiting) {
     switch (t.kind) {
         case "f64":
         case "bigint":
@@ -1088,15 +1099,17 @@ function canBoxDynComposite(t, getRecord, getUnion, visiting = new Set()) {
         case "bytes":
         case "regex":
         case "url":
+        case "searchParams":
             return true;
         case "func":
-            return canBoxFuncIntoDyn(t, getRecord, getUnion);
+            return canBoxFuncIntoDyn(t, getRecord, getUnion, visiting);
         case "set":
-            return t.elem.kind === "dyn";
+            return canConvertToDyn(t.elem, getRecord, getUnion, visiting) && canDynCheckTo(t.elem, getRecord, getUnion, visiting);
         case "map":
-            return t.key.kind === "dyn" && t.value.kind === "dyn";
+            return canConvertToDyn(t.key, getRecord, getUnion, visiting) && canDynCheckTo(t.key, getRecord, getUnion, visiting) &&
+                canConvertToDyn(t.value, getRecord, getUnion, visiting) && canDynCheckTo(t.value, getRecord, getUnion, visiting);
         case "object":
-            return t.className === "%Error" || isDynTypedRefType(t);
+            return RUNTIME_ERROR_CLASSES.has(t.className) || isDynTypedRefType(t);
         case "array":
             return canBoxDynComposite(t.elem, getRecord, getUnion, visiting);
         case "record": {
@@ -1109,11 +1122,16 @@ function canBoxDynComposite(t, getRecord, getUnion, visiting = new Set()) {
             if (visiting.has(t.shapeId))
                 return true;
             visiting.add(t.shapeId);
-            for (const field of shape.fields) {
-                if (!canBoxDynComposite(field.type, getRecord, getUnion, visiting))
-                    return false;
+            try {
+                for (const field of shape.fields) {
+                    if (!canBoxDynComposite(field.type, getRecord, getUnion, visiting))
+                        return false;
+                }
+                return !shape.indexValue || canBoxDynComposite(shape.indexValue, getRecord, getUnion, visiting);
+            }
+            finally {
+                visiting.delete(t.shapeId);
             }
-            return !shape.indexValue || canBoxDynComposite(shape.indexValue, getRecord, getUnion, visiting);
         }
         case "union": {
             const def = getUnion(t.unionId);
@@ -1122,11 +1140,16 @@ function canBoxDynComposite(t, getRecord, getUnion, visiting = new Set()) {
             if (visiting.has(t.unionId))
                 return true;
             visiting.add(t.unionId);
-            for (const arm of def.arms) {
-                if (!canBoxDynComposite(arm, getRecord, getUnion, visiting))
-                    return false;
+            try {
+                for (const arm of def.arms) {
+                    if (!canBoxDynComposite(arm, getRecord, getUnion, visiting))
+                        return false;
+                }
+                return true;
+            }
+            finally {
+                visiting.delete(t.unionId);
             }
-            return true;
         }
         default:
             return false;
@@ -1137,7 +1160,27 @@ function canBoxDynComposite(t, getRecord, getUnion, visiting = new Set()) {
  * undefined-armed unions of JSON-safe arms, adaptable function types,
  * and the runtime HANDLE kinds (a tag-checked reference unwrap —
  * DYN_HANDLE_KINDS). */
-export function canDynCheckTo(t, getRecord, getUnion) {
+export function canDynCheckTo(t, getRecord, getUnion, visiting = new Set()) {
+    const key = `checked:${typeKey(t)}`;
+    if (visiting.has(key))
+        return true;
+    const result = canDynCheckToAt(t, getRecord, getUnion, visiting);
+    if (result)
+        visiting.add(key);
+    else
+        clearDynConversionResults(visiting);
+    return result;
+}
+/** Reuse completed subgraphs within one conversion query. A failed branch
+ * invalidates successes that may depend on a coinductive back-edge to it;
+ * active recursion keys remain until their owning calls unwind. */
+function clearDynConversionResults(visiting) {
+    for (const key of visiting) {
+        if (key.startsWith("boxed:") || key.startsWith("checked:"))
+            visiting.delete(key);
+    }
+}
+function canDynCheckToAt(t, getRecord, getUnion, visiting) {
     // Unknown fields keep an owned dyn subtree; checking the surrounding
     // record/array still validates its layout. This is broader than the
     // stringify/island JSON domain, which cannot assume opaque slots are
@@ -1145,26 +1188,48 @@ export function canDynCheckTo(t, getRecord, getUnion) {
     // unknown record fields with the undefined value.
     if (isJsonSafeAt(t, getRecord, getUnion, false, false, new Set(), true))
         return true;
-    if (t.kind === "bigint" || t.kind === "symbol" || t.kind === "set" && t.elem.kind === "dyn")
-        return true;
-    if (t.kind === "map" && t.key.kind === "dyn" && t.value.kind === "dyn")
+    if (t.kind === "bigint" || t.kind === "symbol" || t.kind === "date" || t.kind === "searchParams")
         return true;
+    if (t.kind === "map" || t.kind === "set")
+        return canBoxDynComposite(t, getRecord, getUnion, visiting);
     if (t.kind === "bytes")
         return true;
     if (t.kind === "classval")
         return true;
     if (t.kind === "generator")
         return true;
+    if (t.kind === "promise")
+        return t.inner.kind === "dyn" || t.inner.kind === "void" || canDynCheckToAt(t.inner, getRecord, getUnion, visiting);
     if (t.kind === "object" && t.className === "%Error")
         return true;
     // Native class capsules already support checked extraction at ordinary
     // boundaries. Callable adapters use the same identity/brand check.
     if (isDynTypedRefType(t))
         return true;
-    if (t.kind === "array" && isDynTypedRefType(t.elem))
-        return true;
+    if (t.kind === "array") {
+        const key = typeKey(t);
+        if (visiting.has(key))
+            return false;
+        visiting.add(key);
+        const result = canDynCheckTo(t.elem, getRecord, getUnion, visiting);
+        visiting.delete(key);
+        return result;
+    }
+    if (t.kind === "record") {
+        const key = typeKey(t);
+        if (visiting.has(key))
+            return false;
+        const shape = getRecord(t.shapeId);
+        if (!shape || shapeHasAccessorSlots(shape))
+            return false;
+        visiting.add(key);
+        const result = shape.fields.every((field) => canDynCheckTo(field.type, getRecord, getUnion, visiting)) &&
+            (!shape.indexValue || canDynCheckTo(shape.indexValue, getRecord, getUnion, visiting));
+        visiting.delete(key);
+        return result;
+    }
     if (t.kind === "func")
-        return canAdaptDynFuncTo(t, getRecord, getUnion);
+        return canAdaptDynFuncTo(t, getRecord, getUnion, visiting);
     if (DYN_HANDLE_KINDS.has(t.kind))
         return true;
     if (t.kind === "union") {
@@ -1172,7 +1237,7 @@ export function canDynCheckTo(t, getRecord, getUnion) {
         // Optional native callbacks and handles retain the same checked
         // conversion as their bare value. The union matcher selects the arm
         // before its adapter/extractor runs.
-        return !!def && def.arms.every((a) => isUnitType(a) || (a.kind !== "union" && canDynCheckTo(a, getRecord, getUnion)));
+        return !!def && def.arms.every((a) => isUnitType(a) || (a.kind !== "union" && canDynCheckTo(a, getRecord, getUnion, visiting)));
     }
     return false;
 }
@@ -1180,7 +1245,7 @@ export function canDynCheckTo(t, getRecord, getUnion) {
  * every param dyn or dynCheckable (the thunk validates dyn arguments into
  * them), return void, dyn, or dyn-convertible (the thunk converts it
  * back). */
-export function canBoxFuncIntoDyn(t, getRecord, getUnion) {
+export function canBoxFuncIntoDyn(t, getRecord, getUnion, visiting = new Set()) {
     return (t.kind === "func" &&
         // Typed rest occupies the final native array parameter; its thunk
         // checks a fresh array containing all remaining call arguments.
@@ -1191,23 +1256,23 @@ export function canBoxFuncIntoDyn(t, getRecord, getUnion) {
         // thunk (wrapped cells unwrap by reference, dyn data deep-copies) —
         // the checker-'any' callback params of the routed-dispatch lane
         // (`bag.list.map((x) => ...)` with x typed any).
-        t.params.every((p) => p.kind === "dyn" || p.kind === "jsval" || canDynCheckTo(p, getRecord, getUnion)) &&
+        t.params.every((p) => p.kind === "dyn" || p.kind === "jsval" || canDynCheckTo(p, getRecord, getUnion, visiting)) &&
         // A jsval return converts through the by-reference wrap
         // (dynFromJsval — the thunk's result conversion), so engine-returning
         // callbacks box too: the routed-dispatch lane's flatMap shape.
-        (t.ret.kind === "void" || t.ret.kind === "dyn" || t.ret.kind === "jsval" || canConvertToDyn(t.ret, getRecord, getUnion)));
+        (t.ret.kind === "void" || t.ret.kind === "dyn" || t.ret.kind === "jsval" || canConvertToDyn(t.ret, getRecord, getUnion, visiting)));
 }
 /** A closure type a dyn function value can ADAPT to (dynCheck): every
  * param dyn or dyn-convertible (the adapter converts typed arguments into
  * dyn), return void, dyn, or dynCheckable (the adapter validates the dyn
  * result). */
-export function canAdaptDynFuncTo(t, getRecord, getUnion) {
+export function canAdaptDynFuncTo(t, getRecord, getUnion, visiting = new Set()) {
     return (t.kind === "func" &&
         // Checked rest and arguments packs retain all actual arguments. Typed
         // and island rest ABIs still require their own conversion plan.
         (t.rest !== true || t.restAbi === undefined) &&
-        t.params.every((p) => p.kind === "dyn" || canConvertToDyn(p, getRecord, getUnion)) &&
-        (t.ret.kind === "void" || t.ret.kind === "dyn" || canDynCheckTo(t.ret, getRecord, getUnion)));
+        t.params.every((p) => p.kind === "dyn" || canConvertToDyn(p, getRecord, getUnion, visiting)) &&
+        (t.ret.kind === "void" || t.ret.kind === "dyn" || canDynCheckTo(t.ret, getRecord, getUnion, visiting)));
 }
 /** The MARSHAL-direction boundary (jsMarshal): everything that can cross
  * out and back (canCrossIslandBoundary) plus qualifying closures — those
@@ -1267,7 +1332,9 @@ export function canExitIslandToType(t, getRecord, getUnion) {
     return false;
 }
 const DYN_ASYNC_LIB_FNS = new Set([
-    "async.awaitDyn", "timers.immediatePromise",
+    "fs.callbackValue", "fs.callbackCall",
+    "async.awaitDyn", "timers.immediatePromise", "crypto.native",
+    "dyn.promiseAll",
     "process.onUncaughtException", "process.offUncaughtException",
     "process.onUnhandledRejection", "process.offUnhandledRejection",
     "process.onRejectionHandled", "process.offRejectionHandled",
@@ -1287,7 +1354,9 @@ function scanRuntimeFeatures(mod, stopAt) {
         processEvents: false, emitter: (mod.classes ?? []).some((c) => c.name === RUNTIME_EMITTER_CLASS),
         stream: (mod.classes ?? []).some((c) => RUNTIME_STREAM_CLASSES.has(c.name)),
         zlib: mod.embedded?.edges.some((e) => e.to === "node:zlib") ?? false,
-        dc: false, assert: false, dynInvoke: false, dynAsync: false, inspect: false,
+        dc: false, assert: false, dynInvoke: false,
+        dynAsync: mod.functions.some((fn) => fn.async === true && fn.generator === undefined && fn.returnType.kind === "dyn"),
+        inspect: false,
         childProcess: false, net: false, symbol: false, bigint: false, searchParams: false,
         qs: false, parseArgs: false, fsWatch: false, nodeTest: false, dgram: false,
         http: false, http2: false, tls: false, tlsCa: false,
@@ -1298,7 +1367,7 @@ function scanRuntimeFeatures(mod, stopAt) {
             const fn = node.fn;
             if (fn === "regexp.escape" || fn === "dyn.nativeRegexIs")
                 features.regex = true;
-            if (fn === "text.decodeLegacy")
+            if (fn === "text.decodeLegacy" || fn === "text.decodeLegacyOptions" || fn === "text.decodeStream")
                 features.legacyTextDecoder = true;
             if (fn.startsWith("fetch."))
                 features.fetch = true;
@@ -1317,7 +1386,7 @@ function scanRuntimeFeatures(mod, stopAt) {
                 features.dc = true;
             if (fn.startsWith("assert."))
                 features.assert = true;
-            if (fn === "dyn.defineProps" || fn === "dyn.defineProperty" || fn === "dyn.objCreateWithProperties" || fn === "dyn.arrayProtoCall" || fn === "dyn.arrayPrototype")
+            if (fn === "dyn.defineProps" || fn === "dyn.definePrototypeProps" || fn === "dyn.defineProperty" || fn === "dyn.objCreateWithProperties" || fn === "dyn.arrayProtoCall" || fn === "dyn.arrayPrototype" || fn === "dyn.functionApply" || fn === "dyn.builtinMethod")
                 features.dynInvoke = true;
             if (DYN_ASYNC_LIB_FNS.has(fn))
                 features.dynAsync = true;
@@ -1368,7 +1437,7 @@ function scanRuntimeFeatures(mod, stopAt) {
                     features.regex = true;
                     break;
                 case "strIntrinsic":
-                    if (node.method === "toLowerCase" || node.method === "toUpperCase")
+                    if (node.method === "toLowerCase" || node.method === "toUpperCase" || node.method === "normalize")
                         features.regex = true;
                     break;
                 case "arrIntrinsic":
@@ -1749,6 +1818,7 @@ const LIB_MODE_REFUSED_PREFIXES = [
     // exclude — refuse the surface like the rest of the event-loop family.
     ["fs.existsChk", "the async fs callback surface (fs.exists)"],
     ["fs.renameCb", "the async fs callback surface (fs.rename)"],
+    ["fs.callback", "the async filesystem callback surface"],
     ["zlib.deflateCb", "the async node:zlib callback surface"],
     ["zlib.inflateCb", "the async node:zlib callback surface"],
     ["zlib.deflateRawCb", "the async node:zlib callback surface"],
@@ -1968,6 +2038,22 @@ 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([
+    "text.encodeInto",
+    "buffer.isAscii",
+    "buffer.isUtf8",
+    "buffer.transcode",
+    "cp.spawnDynamic",
+    "child.onDyn",
+    "text.decoderEncoding",
+    "dyn.construct",
+    "dyn.reflectApply",
+    "dyn.reflectGet",
+    "dyn.reflectSet",
+    "dyn.reflectDefine",
+    "dyn.abstractEq",
+    "text.decodeOptions",
+    "text.decodeStream",
+    "text.decodeLegacyOptions",
     "dyn.nativeSetNew",
     "ffi.argument",
     "ffi.memoryModule",
@@ -1979,6 +2065,10 @@ export const MAY_THROW_LIB_FNS = new Set([
     "weakMap.new",
     "weakSet.new",
     "dyn.fromEntries",
+    "bytes.constructor",
+    "bytes.instanceOf",
+    "buffer.byteLenDyn",
+    "bytes.construct",
     "arrayBuffer.new",
     "arrayBuffer.byteLengthGetter",
     "arrayBuffer.viewU8C",
@@ -1991,6 +2081,8 @@ export const MAY_THROW_LIB_FNS = new Set([
     "arrayBuffer.viewF32",
     "arrayBuffer.viewF64",
     "arrayBuffer.viewDV",
+    "bytes.bufferSource",
+    "text.decodeBufferSource",
     "bigint.parse",
     "bigint.fromF64",
     "bigint.div",
@@ -2005,12 +2097,17 @@ export const MAY_THROW_LIB_FNS = new Set([
     "bigint.bufferWrite",
     "bigint.dataViewGet",
     "bigint.dataViewSet",
+    "fetch.requestNew",
+    "fetch.headersNew",
     "fetch.responseNew",
     "fetch.abortTimeout",
     "fetch.abortAny",
+    "abort.timeout",
+    "abort.any",
     "fetch.streamNew",
     "fetch.streamFrom",
     "num.toFixed",
+    "num.toStringRadix",
     "insp.jsonDyn",
     // diagnostics_channel: publish runs subscribers synchronously (a throw
     // propagates — the documented divergence from triggerUncaughtException);
@@ -2170,6 +2267,8 @@ export const MAY_THROW_LIB_FNS = new Set([
     "readable.unshift",
     "readable.unshiftStr",
     "readable.read",
+    "readable.readDyn",
+    "stream.onDyn",
     "readable.resume",
     "readable.pipe",
     "readable.unpipe",
@@ -2217,18 +2316,23 @@ export const MAY_THROW_LIB_FNS = new Set([
     // Error messages use the same coercion protocol before installing cause.
     "error.newOptions",
     "error.ctorOptions",
+    "error.toString",
+    "error.stack",
     "error.cause",
     "error.setCause",
     "error.deleteCause",
     "dyn.objectTag",
     // Numeric coercion runs user valueOf/toString — throws propagate.
     "dyn.numberConstructor",
+    "dyn.bigintConstructor",
     "dyn.toNumberCoerce",
     "dyn.add",
     "dyn.arithmetic",
+    "dyn.compare",
     "dyn.bitwise",
     "dyn.proxyNew",
     "dyn.classBasePrototype",
+    "dyn.classInherit",
     "dyn.classSuper",
     "dyn.hasKey",
     "child.kill",
@@ -2271,9 +2375,11 @@ export const MAY_THROW_LIB_FNS = new Set([
     "date.nativeNew",
     "date.checkedValue",
     "util.parseArgs",
+    "util.parseEnv",
     // decodeURIComponent throws the spec's URIError on bad hex/invalid
     // UTF-8 octets (encodeURIComponent never throws — see the IrLibFn doc).
     "str.decodeUriComponent",
+    "str.decodeUri",
     // The base64 globals: atob/btoa throw the catchable DOMException
     // InvalidCharacterError on malformed input; the zero-argument form
     // always throws Node's TypeError [ERR_MISSING_ARGS].
@@ -2298,6 +2404,7 @@ export const MAY_THROW_LIB_FNS = new Set([
     "dyn.propertyIsEnumerable",
     "dyn.assign",
     "dyn.copyDataProperties",
+    "dyn.objectRest",
     // variadic Object.assign: spread flattening throws V8's spread-call
     // TypeErrors; the final copy throws ToObject on a nullish target
     "dyn.packPushSpread",
@@ -2308,6 +2415,7 @@ export const MAY_THROW_LIB_FNS = new Set([
     "dyn.getPrototype",
     "dyn.setPrototype",
     "dyn.getOwnPropertyNames",
+    "dyn.ownKeys",
     "dyn.getOwnPropertySymbols",
     "dyn.getOwnPropertyDescriptors",
     "dyn.preventExtensions",
@@ -2320,12 +2428,15 @@ export const MAY_THROW_LIB_FNS = new Set([
     // new RegExp compiles the pattern eagerly: an invalid pattern or flag
     // throws Node's catchable SyntaxError at construction.
     "regex.new",
+    "regex.resetLastIndex",
     "regex.newChecked",
     "dyn.keySet",
     "dyn.keySetComputed",
     "process.builtinId",
     "process.builtinModule",
     "process.builtinUnsupported",
+    "fs.callbackValue",
+    "fs.callbackCall",
     "dyn.keyDelete",
     "dyn.keyDeleteComputed",
     "dyn.hasKeyComputed",
@@ -2343,10 +2454,14 @@ export const MAY_THROW_LIB_FNS = new Set([
     "dyn.toString",
     "string.fromCodePoint",
     "dyn.defineProps",
+    "dyn.definePrototypeProps",
+    "dyn.bagGet",
+    "dyn.bagSet",
     "dyn.defineProperty",
     "dyn.getOwnPropertyDescriptor",
     "dyn.arrayProtoCall",
     "process.chdir",
+    "process.loadEnvFile",
     "fs.realpathSync",
     "fs.realpathNativeSync",
     "fs.readFileSync",
@@ -2372,6 +2487,7 @@ export const MAY_THROW_LIB_FNS = new Set([
     // on a row that is not a [name, value] pair. The rest of the sp family
     // never throws.
     "sp.fromPairs",
+    "sp.newChecked",
     "fs.statSync",
     "crypto.randomBytesToString",
     "crypto.randomBytes",
@@ -2396,6 +2512,10 @@ export const MAY_THROW_LIB_FNS = new Set([
     "crypto.pbkdf2",
     "crypto.randomBytesCb",
     "crypto.pbkdf2Cb",
+    "crypto.hkdf",
+    "crypto.hkdfCb",
+    "crypto.scrypt",
+    "crypto.scryptCb",
     "buffer.concat",
     "buffer.concatLen",
     "buffer.fromDyn",
@@ -2493,6 +2613,10 @@ export const MAY_THROW_LIB_FNS = new Set([
     "fs.fstatSync",
     "fs.fchmodSync",
     "fs.fsyncSync",
+    "fs.fdatasyncSync",
+    "fs.ftruncateSync",
+    "fs.readvSync",
+    "fs.writevSync",
     "fs.linkSync",
     "fs.writeFileModeSync",
     "fs.mkdirModeSync",