@scriptc/compiler 0.2.3 → 0.2.5

package/dist/ir/ir.js

@@ -1,11 +1,25 @@
 import { InternalCompilerError } from "../errors.js";
-import { everyModuleNode, everyExprChild, everyStmtChild } from "./traverse.js";
 export const BYTES_ELEMENT_SIZE = {
-    u8: 1, u8c: 1, i8: 1, u16: 2, i16: 2, u32: 4, i32: 4, f32: 4, f64: 8,
+    u8: 1,
+    u8c: 1,
+    i8: 1,
+    u16: 2,
+    i16: 2,
+    u32: 4,
+    i32: 4,
+    f32: 4,
+    f64: 8,
 };
 export const BYTES_ELEMENT_NAME = {
-    u8: "Uint8Array", u8c: "Uint8ClampedArray", i8: "Int8Array", u16: "Uint16Array", i16: "Int16Array",
-    u32: "Uint32Array", i32: "Int32Array", f32: "Float32Array", f64: "Float64Array",
+    u8: "Uint8Array",
+    u8c: "Uint8ClampedArray",
+    i8: "Int8Array",
+    u16: "Uint16Array",
+    i16: "Int16Array",
+    u32: "Uint32Array",
+    i32: "Int32Array",
+    f32: "Float32Array",
+    f64: "Float64Array",
 };
 const POINTER_HANDLE_KINDS = [
     "stats",
@@ -33,10 +47,7 @@ function irKindSet(kinds) {
 }
 /** The opaque runtime handle kinds. procStream is the one scalar handle;
  * every other handle has pointer representation. */
-const HANDLE_KIND_LIST = [
-    ...POINTER_HANDLE_KINDS,
-    "procStream",
-];
+const HANDLE_KIND_LIST = [...POINTER_HANDLE_KINDS, "procStream"];
 export const HANDLE_KINDS = irKindSet(HANDLE_KIND_LIST);
 /** The IR kinds represented as pointers in native code. */
 const POINTER_KIND_LIST = [
@@ -140,9 +151,38 @@ export const REF_TRUTHY_KINDS = new Set([
     // symbol is not a JS object, but every symbol is truthy — the same
     // constant-true answer.
     "symbol",
-    "date", "array", "map", "set", "regex", "url", "searchParams", "stats", "fileHandle", "spawnRes", "child",
-    "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq",
-    "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "procStream", "bytes", "func", "object", "record", "promise",
+    "date",
+    "array",
+    "map",
+    "set",
+    "regex",
+    "url",
+    "searchParams",
+    "stats",
+    "fileHandle",
+    "spawnRes",
+    "child",
+    "netServer",
+    "netSocket",
+    "http2Session",
+    "http2Stream",
+    "dgramSocket",
+    "testCtx",
+    "httpReq",
+    "httpRes",
+    "httpClientReq",
+    "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.
@@ -244,15 +284,39 @@ export function setOf(elem) {
  * classes and arrays can point back at their collection, so constructors
  * must carry key tracing as well as retain/release adapters. */
 export function isIdentityCollectionKey(t) {
-    return t.kind === "record" || t.kind === "object" || t.kind === "array" ||
-        t.kind === "netServer" || t.kind === "symbol";
+    return (t.kind === "record" ||
+        t.kind === "object" ||
+        t.kind === "array" ||
+        t.kind === "netServer" ||
+        t.kind === "symbol");
+}
+/** 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 function isPrimitiveCollectionKey(t, unionArms) {
+    if (t.kind === "union")
+        return !!unionArms?.length && unionArms.every((arm) => isPrimitiveCollectionKey(arm));
+    return (t.kind === "f64" ||
+        t.kind === "string" ||
+        t.kind === "bigint" ||
+        t.kind === "bool" ||
+        t.kind === "symbol" ||
+        isUnitType(t));
 }
-/** 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. */
 export function isSupportedMapKey(t, unionArms) {
-    return t.kind === "f64" || t.kind === "string" || t.kind === "dyn" || isIdentityCollectionKey(t) ||
-        (t.kind === "union" && unionArms !== undefined && unionArms.length > 0 && unionArms.every(isIdentityCollectionKey));
+    return (isCollectionValueKey(t) ||
+        t.kind === "dyn" ||
+        (t.kind === "union" &&
+            unionArms !== undefined &&
+            unionArms.length > 0 &&
+            unionArms.every((arm) => isCollectionValueKey(arm) || isUnitType(arm))));
+}
+function isCollectionValueKey(t) {
+    return (t.kind === "f64" ||
+        t.kind === "string" ||
+        t.kind === "bigint" ||
+        t.kind === "bool" ||
+        isIdentityCollectionKey(t));
 }
 /** Set elements and Map keys share storage, equality and ownership rules. */
 export function isSupportedSetElem(t, unionArms) {
@@ -326,9 +390,7 @@ export function isSupportedMapValue(t) {
  * Nested index-signature RECORDS ride the record kind like any other.
  * Shared frontend (mapType) / validator. */
 export function isSupportedIndexValue(t) {
-    return (t.kind === "dyn" ||
-        t.kind === "func" ||
-        isSupportedMapValue(t));
+    return t.kind === "dyn" || t.kind === "func" || isSupportedMapValue(t);
 }
 export function funcOf(params, ret) {
     return { kind: "func", params, ret };
@@ -338,7 +400,8 @@ export function funcOf(params, ret) {
  * arbitrary data siblings require a separate runtime narrowing operation.
  * Share this rule across checker mapping, synthesized unions and validation. */
 export function unionContainerArmsOk(arms) {
-    return arms.every((a, i) => (a.kind !== "map" && a.kind !== "set" && a.kind !== "promise") || arms.every((b, j) => j === i || isUnitType(b)));
+    return arms.every((a, i) => (a.kind !== "map" && a.kind !== "set" && a.kind !== "promise") ||
+        arms.every((b, j) => j === i || isUnitType(b)));
 }
 /** Canonical, injective text form of an IrType — the building block of
  * shape/union identity keys, generic-function instantiation keys, and the
@@ -403,10 +466,14 @@ export function typeEquals(a, b) {
     // Dispatch once: a chain of negative narrowing checks repeatedly retags
     // the remaining variants when this comparator runs in the native compiler.
     switch (a.kind) {
-        case "array": return b.kind === "array" && typeEquals(a.elem, b.elem);
-        case "bytes": return b.kind === "bytes" && a.elem === b.elem;
-        case "map": return b.kind === "map" && typeEquals(a.key, b.key) && typeEquals(a.value, b.value);
-        case "set": return b.kind === "set" && typeEquals(a.elem, b.elem);
+        case "array":
+            return b.kind === "array" && typeEquals(a.elem, b.elem);
+        case "bytes":
+            return b.kind === "bytes" && a.elem === b.elem;
+        case "map":
+            return b.kind === "map" && typeEquals(a.key, b.key) && typeEquals(a.value, b.value);
+        case "set":
+            return b.kind === "set" && typeEquals(a.elem, b.elem);
         case "func":
             return (b.kind === "func" &&
                 a.params.length === b.params.length &&
@@ -415,20 +482,27 @@ export function typeEquals(a, b) {
                 a.argumentsAll === b.argumentsAll &&
                 a.params.every((p, i) => typeEquals(p, b.params[i])) &&
                 typeEquals(a.ret, b.ret));
-        case "object": return b.kind === "object" && a.className === b.className;
-        case "classval": return b.kind === "classval" && a.className === b.className;
-        case "moduleNs": return b.kind === "moduleNs" && a.moduleId === b.moduleId;
+        case "object":
+            return b.kind === "object" && a.className === b.className;
+        case "classval":
+            return b.kind === "classval" && a.className === b.className;
+        case "moduleNs":
+            return b.kind === "moduleNs" && a.moduleId === b.moduleId;
         // Shapes and unions are interned, so their ids determine equality.
-        case "record": return b.kind === "record" && a.shapeId === b.shapeId;
-        case "union": return b.kind === "union" && a.unionId === b.unionId;
-        case "promise": return b.kind === "promise" && typeEquals(a.inner, b.inner);
+        case "record":
+            return b.kind === "record" && a.shapeId === b.shapeId;
+        case "union":
+            return b.kind === "union" && a.unionId === b.unionId;
+        case "promise":
+            return b.kind === "promise" && typeEquals(a.inner, b.inner);
         case "generator":
             return (b.kind === "generator" &&
                 (a.async === true) === (b.async === true) &&
                 typeEquals(a.yieldT, b.yieldT) &&
                 typeEquals(a.retT, b.retT) &&
                 typeEquals(a.nextT, b.nextT));
-        default: return a.kind === b.kind;
+        default:
+            return a.kind === b.kind;
     }
 }
 /** True for types whose values are heap-allocated and reference-counted.
@@ -723,9 +797,9 @@ export function isJsonStringifySafeType(t, getRecord, getUnion) {
  * the type-directed serializer, checked-island boundary, or root-undefined
  * contract; callers must select the checked runtime traversal explicitly. */
 export function isJsonStringifyDynamicType(t, getRecord, getUnion) {
-    return (t.kind === "record" || t.kind === "array" || t.kind === "union") &&
+    return ((t.kind === "record" || t.kind === "array" || t.kind === "union") &&
         isJsonSafeAt(t, getRecord, getUnion, true, false, new Set(), true) &&
-        !isJsonStringifySafeType(t, getRecord, getUnion);
+        !isJsonStringifySafeType(t, getRecord, getUnion));
 }
 /** The recursion shared by checked JSON conversion and stringification.
  * Ordinary record fields always admit undefined by dropping the key. Array
@@ -776,7 +850,9 @@ function isJsonSafeAt(t, getRecord, getUnion, stringify, undefinedAllowed, visit
                 return true; // the recursive knot, union-flavored
             visiting.add(key);
             for (const arm of def.arms) {
-                if (!(arm.kind === "undefinedT" ? undefinedAllowed : isJsonSafeAt(arm, getRecord, getUnion, stringify, undefinedAllowed, visiting, nativeFields)))
+                if (!(arm.kind === "undefinedT"
+                    ? undefinedAllowed
+                    : isJsonSafeAt(arm, getRecord, getUnion, stringify, undefinedAllowed, visiting, nativeFields)))
                     return false;
             }
             return true;
@@ -851,8 +927,11 @@ export function canMarshalFuncIntoIsland(t) {
         t.rest !== true &&
         t.params.length <= MAX_ISLAND_CALLBACK_ARITY &&
         t.params.every((p) => p.kind === "jsval") &&
-        (t.ret.kind === "jsval" || t.ret.kind === "void" ||
-            t.ret.kind === "f64" || t.ret.kind === "bool" || t.ret.kind === "string"));
+        (t.ret.kind === "jsval" ||
+            t.ret.kind === "void" ||
+            t.ret.kind === "f64" ||
+            t.ret.kind === "bool" ||
+            t.ret.kind === "string"));
 }
 /** Parameter types a TYPED closure may declare when it crosses INTO the
  * island as a host function: jsval params take the engine argument as a
@@ -874,7 +953,8 @@ export function isIslandCallbackParamType(t, getRecord, getUnion) {
         // A bare undefined-armed union: every non-undefined arm must be
         // JSON-safe (arms never nest unions, so plain isJsonSafeType applies).
         const def = getUnion(t.unionId);
-        return !!def && def.arms.every((a) => a.kind === "undefinedT" || isJsonSafeType(a, getRecord, getUnion));
+        return (!!def &&
+            def.arms.every((a) => a.kind === "undefinedT" || isJsonSafeType(a, getRecord, getUnion)));
     }
     return false;
 }
@@ -888,7 +968,11 @@ export function isIslandCallbackParamType(t, getRecord, getUnion) {
  * the `.action(async ...)` case). Null for anything else (Promise of
  * composites: still fenced). */
 export function islandCallbackRet(t, getRecord, getUnion) {
-    const tagOf = (r) => r.kind === "void" || r.kind === "jsval" || r.kind === "f64" || r.kind === "bool" || r.kind === "string"
+    const tagOf = (r) => r.kind === "void" ||
+        r.kind === "jsval" ||
+        r.kind === "f64" ||
+        r.kind === "bool" ||
+        r.kind === "string"
         ? r.kind
         : null;
     if (t.kind === "promise") {
@@ -1060,10 +1144,14 @@ export function canConvertToDyn(t, getRecord, getUnion, visiting = new Set()) {
         // invalid-input probes iterate `[1, null, () => {}, true]` — the
         // union's func arm crosses through the checked-dynamic function
         // 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, visiting)) ||
-            (a.kind === "promise" && canConvertToDyn(a, getRecord, getUnion, visiting)));
+        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, visiting)) ||
+                (a.kind === "promise" && canConvertToDyn(a, getRecord, getUnion, visiting))));
     }
     return false;
 }
@@ -1105,16 +1193,19 @@ function canBoxDynCompositeAt(t, getRecord, getUnion, visiting) {
         case "func":
             return canBoxFuncIntoDyn(t, getRecord, getUnion, visiting);
         case "set":
-            return canConvertToDyn(t.elem, getRecord, getUnion, visiting) && canDynCheckTo(t.elem, getRecord, getUnion, visiting);
+            return (canConvertToDyn(t.elem, getRecord, getUnion, visiting) &&
+                canDynCheckTo(t.elem, getRecord, getUnion, visiting));
         case "map":
-            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);
+            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 RUNTIME_ERROR_CLASSES.has(t.className) || isDynTypedRefType(t);
         case "array":
             // Process streams have scalar storage only in fields, closures and
             // unions. A direct procStream array has no native ScrArr layout.
-            return t.elem.kind !== "procStream" && canBoxDynComposite(t.elem, getRecord, getUnion, visiting);
+            return (t.elem.kind !== "procStream" && canBoxDynComposite(t.elem, getRecord, getUnion, visiting));
         case "record": {
             const shape = getRecord(t.shapeId);
             if (!shape)
@@ -1130,7 +1221,7 @@ function canBoxDynCompositeAt(t, getRecord, getUnion, visiting) {
                     if (!canBoxDynComposite(field.type, getRecord, getUnion, visiting))
                         return false;
                 }
-                return !shape.indexValue || canBoxDynComposite(shape.indexValue, getRecord, getUnion, visiting);
+                return (!shape.indexValue || canBoxDynComposite(shape.indexValue, getRecord, getUnion, visiting));
             }
             finally {
                 visiting.delete(t.shapeId);
@@ -1204,7 +1295,9 @@ function canDynCheckToAt(t, getRecord, getUnion, visiting) {
     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);
+        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
@@ -1244,7 +1337,8 @@ function canDynCheckToAt(t, getRecord, getUnion, visiting) {
         // 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, visiting)));
+        return (!!def &&
+            def.arms.every((a) => isUnitType(a) || (a.kind !== "union" && canDynCheckTo(a, getRecord, getUnion, visiting))));
     }
     return false;
 }
@@ -1257,7 +1351,8 @@ export function canBoxFuncIntoDyn(t, getRecord, getUnion, visiting = new Set())
         // Typed rest occupies the final native array parameter; its thunk
         // checks a fresh array containing all remaining call arguments.
         // Island rest keeps its separate engine host-callback adapter.
-        (t.rest !== true || t.restAbi === undefined ||
+        (t.rest !== true ||
+            t.restAbi === undefined ||
             (t.restAbi === "typed" && t.params.at(-1)?.kind === "array")) &&
         // A jsval (island) param converts through scr_jsval_from_dyn in the
         // thunk (wrapped cells unwrap by reference, dyn data deep-copies) —
@@ -1267,7 +1362,10 @@ export function canBoxFuncIntoDyn(t, getRecord, getUnion, visiting = new Set())
         // 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, visiting)));
+        (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
@@ -1279,7 +1377,9 @@ export function canAdaptDynFuncTo(t, getRecord, getUnion, visiting = new Set())
         // 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, visiting)) &&
-        (t.ret.kind === "void" || t.ret.kind === "dyn" || canDynCheckTo(t.ret, 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
@@ -1303,13 +1403,20 @@ export function canMarshalIntoIsland(t, getRecord, getUnion) {
  * Promise.all arm). Null = outside the domain (the boundary fence). */
 export function islandPromisePayloadTag(inner) {
     switch (inner.kind) {
-        case "void": return "void";
-        case "f64": return "f64";
-        case "bool": return "bool";
-        case "string": return "string";
-        case "jsval": return "jsval";
-        case "array": return inner.elem.kind === "jsval" ? "jsvalArr" : null;
-        default: return null;
+        case "void":
+            return "void";
+        case "f64":
+            return "f64";
+        case "bool":
+            return "bool";
+        case "string":
+            return "string";
+        case "jsval":
+            return "jsval";
+        case "array":
+            return inner.elem.kind === "jsval" ? "jsvalArr" : null;
+        default:
+            return null;
     }
 }
 export function canExitIslandToType(t, getRecord, getUnion) {
@@ -1334,1340 +1441,8 @@ export function canExitIslandToType(t, getRecord, getUnion) {
         // jsval-element-array data arm beside units — the engine's undefined
         // takes the undefined arm, everything else the array exit.
         const dataArms = def.arms.filter((a) => !isUnitType(a));
-        return dataArms.length === 1 && dataArms[0].kind === "array" && dataArms[0].elem.kind === "jsval";
+        return (dataArms.length === 1 && dataArms[0].kind === "array" && dataArms[0].elem.kind === "jsval");
     }
     return false;
 }
-const DYN_ASYNC_LIB_FNS = new Set([
-    "fs.callbackValue", "fs.callbackCall",
-    "async.awaitDyn", "timers.immediatePromise", "crypto.native",
-    "dyn.promiseAll",
-    "process.onUncaughtException", "process.offUncaughtException",
-    "process.onUnhandledRejection", "process.offUnhandledRejection",
-    "process.onRejectionHandled", "process.offRejectionHandled",
-    "process.onWarning", "process.offWarning", "process.emitWarning", "util.styleText",
-    "als.new", "als.get", "als.run", "als.exitRun", "als.enterWith", "als.disable",
-    "dc.chanBindStore", "dc.chanUnbindStore", "dc.chanRunStores",
-]);
-/** Inspect types and expressions together in one traversal. This is a fresh
- * snapshot: callers may mutate an IR module between compilation passes. */
-export function moduleRuntimeFeatures(mod) {
-    return scanRuntimeFeatures(mod);
-}
-function scanRuntimeFeatures(mod, stopAt) {
-    const features = {
-        regex: false, copying: false, legacyTextDecoder: false, fileHandle: false,
-        fetch: mod.embedded?.modules.some((m) => m.usesFetch === true) ?? false,
-        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: 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,
-    };
-    const keepGoing = () => stopAt === undefined || !features[stopAt];
-    const expr = (node) => {
-        if (node.kind === "libCall") {
-            const fn = node.fn;
-            if (fn === "regexp.escape" || fn === "dyn.nativeRegexIs" || fn === "util.stripVTControlCharacters")
-                features.regex = true;
-            if (fn === "text.decodeLegacy" || fn === "text.decodeLegacyOptions" || fn === "text.decodeStream")
-                features.legacyTextDecoder = true;
-            if (fn.startsWith("fetch."))
-                features.fetch = true;
-            if (PROCESS_EVENT_LIB_FNS.has(fn))
-                features.processEvents = true;
-            if (fn.startsWith("emitter."))
-                features.emitter = true;
-            if (fn.startsWith("readable.") || fn.startsWith("writable.") || fn.startsWith("duplex.") ||
-                fn.startsWith("transform.") || fn.startsWith("passthrough.") || fn.startsWith("sc.") ||
-                fn.startsWith("stream.set") || fn === "stream.destroy" || fn === "stream.destroyErr" ||
-                fn === "stream.prop" || fn === "stream.errored" || fn === "sp.finished" || fn === "sp.pipeline")
-                features.stream = true;
-            if (fn.startsWith("zlib."))
-                features.zlib = true;
-            if (fn.startsWith("dc."))
-                features.dc = true;
-            if (fn.startsWith("assert."))
-                features.assert = true;
-            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;
-            if (fn.startsWith("insp.") || fn === "console.native" || fn === "global.native" || fn === "util.styleText")
-                features.inspect = true;
-            if (fn.startsWith("cp.") || fn.startsWith("child.") || fn.startsWith("writer.") || fn.startsWith("spawnRes.") ||
-                fn === "process.forkTarget" || fn === "process.connected" || fn === "process.send" || fn === "process.sendCb" ||
-                fn === "process.disconnect" || fn === "process.onMessage" || fn === "process.onDisconnect")
-                features.childProcess = true;
-            if (fn.startsWith("net."))
-                features.net = true;
-            if (fn.startsWith("http.")) {
-                features.net = true;
-                features.http = true;
-            }
-            if (fn.startsWith("tls.") || fn.startsWith("https.") || fn.startsWith("http2.")) {
-                features.net = true;
-                features.http = true;
-                features.tls = true;
-            }
-            if (fn.startsWith("http2.") && !HTTP2_LEGACY_FNS.has(fn))
-                features.http2 = true;
-            if (fn.startsWith("sym.") || fn === "util.isDeepStrictEqual")
-                features.symbol = true;
-            if (fn === "process.hrtimeValue")
-                features.bigint = true;
-            if (fn.startsWith("bigint."))
-                features.bigint = true;
-            if (fn.startsWith("sp.") || fn === "url.searchParams")
-                features.searchParams = true;
-            if (fn === "qs.parse" || fn === "qs.stringify" || fn === "qs.unescape")
-                features.qs = true;
-            if (fn === "util.parseArgs" || fn === "util.isDeepStrictEqual" || fn === "util.styleText")
-                features.parseArgs = true;
-            if (fn === "util.styleText")
-                features.processEvents = true;
-            if (fn.startsWith("fs.watch") || fn.startsWith("watcher."))
-                features.fsWatch = true;
-            if (fn.startsWith("test."))
-                features.nodeTest = true;
-            if (fn.startsWith("dgram.") || fn.startsWith("dns."))
-                features.dgram = true;
-            if (fn.startsWith("tlsca."))
-                features.tlsCa = true;
-        }
-        else {
-            switch (node.kind) {
-                case "regexLit":
-                case "regexIntrinsic":
-                    features.regex = true;
-                    break;
-                case "strIntrinsic":
-                    if (node.method === "toLowerCase" || node.method === "toUpperCase" || node.method === "normalize")
-                        features.regex = true;
-                    break;
-                case "arrIntrinsic":
-                    if (node.method === "toReversed" || node.method === "toSpliced" || node.method === "with" || node.method === "withUndefined")
-                        features.copying = true;
-                    break;
-                case "bytesIntrinsic":
-                    if (node.method === "toReversed" || node.method === "with" || node.method === "join" || node.method === "toArray")
-                        features.copying = true;
-                    break;
-                case "jsOp":
-                    if (node.op === "globalGet" && node.name === "fetch")
-                        features.fetch = true;
-                    break;
-                case "dynInvoke":
-                    features.dynInvoke = true;
-                    break;
-                case "awaitExpr":
-                    if (node.type.kind === "dyn")
-                        features.dynAsync = true;
-                    break;
-                case "dynFrom": {
-                    const boxed = node.value.type;
-                    if (boxed.kind === "promise" || (boxed.kind === "func" && boxed.ret.kind === "promise"))
-                        features.dynAsync = true;
-                    break;
-                }
-            }
-        }
-        return keepGoing();
-    };
-    const type = (node) => {
-        switch (node.kind) {
-            case "regex":
-                features.regex = true;
-                break;
-            case "fileHandle":
-                features.fileHandle = true;
-                break;
-            case "procStream":
-                features.processEvents = true;
-                break;
-            case "child":
-            case "childStream":
-            case "childWriter":
-            case "spawnRes":
-                features.childProcess = true;
-                break;
-            case "netServer":
-            case "netSocket":
-                features.net = true;
-                break;
-            case "http2Session":
-            case "http2Stream":
-                features.net = true;
-                features.http2 = true;
-                break;
-            case "httpReq":
-            case "httpRes":
-            case "httpClientReq":
-                features.net = true;
-                features.http = true;
-                break;
-            case "secureCtx":
-                features.net = true;
-                features.http = true;
-                features.tls = true;
-                break;
-            case "symbol":
-                features.symbol = true;
-                break;
-            case "bigint":
-                features.bigint = true;
-                break;
-            case "searchParams":
-                features.searchParams = true;
-                break;
-            case "fsWatcher":
-                features.fsWatch = true;
-                break;
-            case "testCtx":
-                features.nodeTest = true;
-                break;
-            case "dgramSocket":
-                features.dgram = true;
-                break;
-        }
-        return keepGoing();
-    };
-    if (keepGoing())
-        everyModuleNode(mod, { expr, stmt: keepGoing, type });
-    return features;
-}
-/** 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 function moduleUsesRegex(mod) {
-    return scanRuntimeFeatures(mod, "regex").regex;
-}
-/** 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 function moduleUsesCopying(mod) {
-    return scanRuntimeFeatures(mod, "copying").copying;
-}
-/** 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 function moduleUsesLegacyTextDecoder(mod) {
-    return scanRuntimeFeatures(mod, "legacyTextDecoder").legacyTextDecoder;
-}
-/** 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 function moduleUsesFileHandle(mod) {
-    return scanRuntimeFeatures(mod, "fileHandle").fileHandle;
-}
-/** 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 function moduleUsesFetch(mod) {
-    return scanRuntimeFeatures(mod, "fetch").fetch;
-}
-/** The libCall fns served by the OPTIONAL events unit (scr_events.c):
- * process signal/exit listeners and the piped-stdin surface. */
-const PROCESS_EVENT_LIB_FNS = new Set([
-    "process.stdio",
-    "process.onSignal",
-    "process.offSignal",
-    "process.onExit",
-    "process.offExit",
-    "stdin.onData",
-    "stdin.onEnd",
-    "stdin.onError",
-    "stdin.nextChunk",
-    // node:readline rides the stdin unit (scr_readline.c links beside
-    // scr_events.c under the same gate).
-    "rl.create",
-    "rl.question",
-    "rl.close",
-    "rl.onClose",
-]);
-/** 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 function moduleUsesProcessEvents(mod) {
-    return scanRuntimeFeatures(mod, "processEvents").processEvents;
-}
-/** 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 function moduleUsesEmitter(mod) {
-    return scanRuntimeFeatures(mod, "emitter").emitter;
-}
-/** 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 function moduleUsesStream(mod) {
-    return scanRuntimeFeatures(mod, "stream").stream;
-}
-/** 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 function moduleEmbedsBuiltin(mod, builtin) {
-    return mod.embedded !== undefined && mod.embedded.edges.some((e) => e.to === builtin);
-}
-/** 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 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 function moduleEmbedsCompressedNpm(mod) {
-    return (mod.embedded !== undefined &&
-        mod.embedded.modules.some((m) => m.source.length >= NPM_COMPRESS_MIN || (m.esm ?? "").length >= NPM_COMPRESS_MIN));
-}
-/** 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 function moduleUsesZlib(mod) {
-    return scanRuntimeFeatures(mod, "zlib").zlib;
-}
-/** 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 function moduleUsesDc(mod) {
-    return scanRuntimeFeatures(mod, "dc").dc;
-}
-/** 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 function moduleUsesAssert(mod) {
-    return scanRuntimeFeatures(mod, "assert").assert;
-}
-/** 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 function moduleUsesDynInvoke(mod) {
-    return scanRuntimeFeatures(mod, "dynInvoke").dynInvoke;
-}
-/** 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 function moduleUsesDynAsync(mod) {
-    return scanRuntimeFeatures(mod, "dynAsync").dynAsync;
-}
-export function moduleUsesInspect(mod) {
-    return scanRuntimeFeatures(mod, "inspect").inspect;
-}
-/** 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 function moduleUsesChildProcess(mod) {
-    return scanRuntimeFeatures(mod, "childProcess").childProcess;
-}
-/** 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 function moduleUsesNet(mod) {
-    return scanRuntimeFeatures(mod, "net").net;
-}
-/** 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 function moduleUsesSymbol(mod) {
-    return scanRuntimeFeatures(mod, "symbol").symbol;
-}
-/** 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) {
-    return scanRuntimeFeatures(mod, "bigint").bigint;
-}
-/** 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 function moduleUsesSearchParams(mod) {
-    return scanRuntimeFeatures(mod, "searchParams").searchParams;
-}
-/** 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 function moduleUsesQs(mod) {
-    return scanRuntimeFeatures(mod, "qs").qs;
-}
-/** 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 function moduleUsesParseArgs(mod) {
-    return scanRuntimeFeatures(mod, "parseArgs").parseArgs;
-}
-/** 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 function moduleUsesFsWatch(mod) {
-    return scanRuntimeFeatures(mod, "fsWatch").fsWatch;
-}
-/** 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 function moduleUsesNodeTest(mod) {
-    return scanRuntimeFeatures(mod, "nodeTest").nodeTest;
-}
-/** 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 function moduleUsesDgram(mod) {
-    return scanRuntimeFeatures(mod, "dgram").dgram;
-}
-/** 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 function moduleUsesHttpServer(mod) {
-    return scanRuntimeFeatures(mod, "http").http;
-}
-/** The legacy http2.* libCalls implemented by scr_http.c/scr_tls.c (the
- * allowHTTP1 compatibility slice) — they must NOT pull scr_http2.c, so
- * divergence-57 binaries keep their exact link line. */
-const HTTP2_LEGACY_FNS = new Set([
-    "http2.streamNoop", "http2.streamUndefCall",
-]);
-/** 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 function moduleUsesHttp2(mod) {
-    return scanRuntimeFeatures(mod, "http2").http2;
-}
-/** 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 function moduleUsesTls(mod) {
-    return scanRuntimeFeatures(mod, "tls").tls;
-}
-/** 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 function moduleUsesTlsCa(mod) {
-    return scanRuntimeFeatures(mod, "tlsCa").tlsCa;
-}
-/* ── library mode's async_free gate ──────────────────────────────────────
- * v1 library mode REQUIRES an async_free module graph (ratified): no async
- * functions, no generators, no timers, no event-loop or ambient-process
- * surface anywhere the entry reaches — a static fact of the graph, never a
- * runtime observation. The detector below answers "what does this graph
- * reach that a library artifact cannot link?", first offender with its source anchor;
- * the structural consequence (scr_async.c / scr_child.c and every
- * loop-hooked unit never join a library link) is safe exactly because this
- * refusal ran first. */
-/** libCall families a v1 library artifact refuses, with the surface name the SC4005
- * teaching uses. Prefix match over IrLibFn spellings. */
-const LIB_MODE_REFUSED_PREFIXES = [
-    // fs.exists is the one CALLBACK-async fs op with a real implementation:
-    // its fire rides the timer queue (scr_bytes_io.c), which library links
-    // 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"],
-    ["zlib.inflateRawCb", "the async node:zlib callback surface"],
-    ["zlib.gzipCb", "the async node:zlib callback surface"],
-    ["zlib.gunzipCb", "the async node:zlib callback surface"],
-    ["zlib.unzipCb", "the async node:zlib callback surface"],
-    ["process.stdoutWriteBytesCb", "process.stdout.write completion callbacks"],
-    ["process.stderrWriteBytesCb", "process.stderr.write completion callbacks"],
-    ["timers.", "the timers surface (setTimeout family)"],
-    ["tp.", "the timers/promises surface"],
-    ["cp.", "the child_process surface"],
-    ["child.", "the child_process surface"],
-    ["spawnRes.", "the child_process surface"],
-    ["process.on", "process signal/exit listeners"],
-    ["process.off", "process signal/exit listeners"],
-    ["stdin.", "the stdin event surface"],
-    ["rl.", "the node:readline surface"],
-    ["net.", "the node:net surface"],
-    ["http.", "the node:http surface"],
-    ["https.", "the node:https surface"],
-    ["http2.", "the node:http2 surface"],
-    ["h2.", "the node:http2 surface"],
-    ["dgram.", "the node:dgram surface"],
-    ["dns.", "the node:dns surface"],
-    ["tls.", "the node:tls surface"],
-    ["fs.watch", "fs.watch"],
-    ["watcher.", "fs.watch"],
-    ["test.", "the node:test surface"],
-    ["readable.", "the node:stream surface"],
-    ["writable.", "the node:stream surface"],
-    ["duplex.", "the node:stream surface"],
-    ["transform.", "the node:stream surface"],
-    ["passthrough.", "the node:stream surface"],
-    ["stream.", "the node:stream surface"],
-    ["als.", "AsyncLocalStorage"],
-    ["urj.", "unhandled-rejection tracking"],
-    ["dc.", "the diagnostics_channel surface"],
-];
-/** Value/type kinds whose mere presence means an excluded unit's code (or
- * a fiber) would have to link. */
-const LIB_MODE_REFUSED_KINDS = new Map([
-    ["promise", "promise values"],
-    ["generator", "generator values"],
-    ["awaitExpr", "await"],
-    ["awaitUnionExpr", "await"],
-    ["yieldExpr", "yield"],
-    ["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"],
-    ["http2Stream", "the node:http2 surface"],
-    ["dgramSocket", "the node:dgram surface"],
-    ["fsWatcher", "fs.watch"],
-    ["testCtx", "the node:test surface"],
-    ["httpReq", "the node:http surface"],
-    ["httpRes", "the node:http surface"],
-    ["httpClientReq", "the node:http surface"],
-    ["secureCtx", "the node:tls surface"],
-]);
-/** 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 function moduleLibAsyncSurface(mod) {
-    for (const fn of mod.functions) {
-        if (fn.async === true)
-            return { surface: `an async function ('${fn.name.replace(/^%/, "")}')`, loc: fn.loc };
-        if (fn.generator !== undefined) {
-            return { surface: `a generator function ('${fn.name.replace(/^%/, "")}')`, loc: fn.loc };
-        }
-    }
-    const entryLoc = { file: mod.sourceFile, start: 0, end: 0 };
-    let found = null;
-    const checkKind = (kind, loc) => {
-        const surface = LIB_MODE_REFUSED_KINDS.get(kind);
-        if (surface === undefined)
-            return true;
-        found = { surface, loc };
-        return false;
-    };
-    everyModuleNode(mod, {
-        type: (node, loc) => checkKind(node.kind, loc),
-        stmt: () => true,
-        expr: (node) => {
-            if (!checkKind(node.kind, node.loc))
-                return false;
-            if (node.kind === "libCall") {
-                for (const [prefix, surface] of LIB_MODE_REFUSED_PREFIXES) {
-                    if (node.fn.startsWith(prefix)) {
-                        found = { surface, loc: node.loc };
-                        return false;
-                    }
-                }
-            }
-            return true;
-        },
-    });
-    if (found !== null)
-        return found;
-    // Safety net: the coarse unit predicates, entry-anchored. Every one of
-    // these units is excluded from library links, so a true answer that the
-    // fine-grained table missed must still refuse.
-    const features = moduleRuntimeFeatures(mod);
-    const coarse = [
-        [features.processEvents, "process signal/exit listeners or the stdin event surface"],
-        [features.net, "the node:net surface"],
-        [features.http, "the node:http surface"],
-        [features.http2, "the node:http2 surface"],
-        [features.dgram, "the node:dgram surface"],
-        [features.fsWatch, "fs.watch"],
-        [features.stream, "the node:stream surface"],
-        [features.tls, "the node:tls surface"],
-        [features.fetch, "fetch"],
-        [features.nodeTest, "the node:test surface"],
-        [features.dynAsync, "the checked-dynamic async surface"],
-        [features.dc, "the diagnostics_channel surface"],
-    ];
-    for (const [on, surface] of coarse) {
-        if (on)
-            return { surface, loc: entryLoc };
-    }
-    return null;
-}
-/* ── the sidecar's determinism attestation ───────────────────────────────
- * `deterministic` is true exactly when the compiled module graph reaches
- * no ambient-nondeterminism or ambient-authority surface (random, live
- * clock, environment, filesystem, machine identity) — a static fact of
- * the graph, proven at compile time, never a runtime hope. Network,
- * timers, scheduling, and child processes are already impossible here:
- * the SC4005 async_free gate refused them before any library artifact
- * emitted. The scan is CONSERVATIVE by design: an ambient family reached
- * anywhere in the graph demotes the attestation even when a finer
- * analysis might prove the specific call pure (e.g. date formatting of a
- * stored value) — the attestation may honestly under-claim, never
- * over-claim (schema rule V14: computed, never defaulted). */
-/** 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 const LIB_NONDETERMINISTIC_PREFIXES = [
-    ["math.random", "Math.random"],
-    ["crypto.random", "crypto randomness"],
-    ["date.", "the live clock (Date)"],
-    ["perf.", "the live clock (performance)"],
-    ["process.env", "environment reads"],
-    ["process.argv", "process.argv"],
-    ["process.cwd", "process.cwd"],
-    ["process.chdir", "process.chdir"],
-    ["process.pid", "process identity"],
-    ["process.getuid", "process identity"],
-    ["process.getgid", "process identity"],
-    ["process.execPath", "process identity"],
-    ["process.uptime", "the live clock (process.uptime)"],
-    ["process.availableMemory", "machine memory state"],
-    ["process.constrainedMemory", "machine memory state"],
-    // process.memoryUsage carries NO row: nothing lowers it — no IrLibFn
-    // spelling exists for it, so a prefix here would be dead. If a lowering
-    // ever lands, its spellings must join this table AND the manifest's
-    // ambient projection (the parity test fails until both agree).
-    ["process.rusage", "machine resource usage (process.resourceUsage)"],
-    ["process.cpu", "the process CPU clock (process.cpuUsage)"],
-    ["process.threadCpu", "the thread CPU clock (process.threadCpuUsage)"],
-    ["process.isTTY", "terminal attachment (isTTY)"],
-    ["process.columns", "terminal geometry (columns)"],
-    ["process.rows", "terminal geometry (rows)"],
-    ["process.kill", "process authority (kill)"],
-    ["process.umask", "process authority (umask)"],
-    ["process.exit", "process authority (exit)"],
-    ["process.setExitCode", "process authority (exit status)"],
-    ["fs.", "the filesystem"],
-    ["os.", "machine/OS identity"],
-    // The CA-store surface reads the host's certificate bundle (and the
-    // NODE_EXTRA_CA_CERTS environment) — machine identity by another name.
-    ["tlsca.", "the host CA store"],
-];
-/** 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 function moduleLibNondeterministicSurface(mod) {
-    let found = null;
-    const expr = (node) => {
-        if (node.kind === "libCall") {
-            for (const [prefix, surface] of LIB_NONDETERMINISTIC_PREFIXES) {
-                if (node.fn.startsWith(prefix)) {
-                    found = surface;
-                    return false;
-                }
-            }
-        }
-        return everyExprChild(node, expr, stmt);
-    };
-    const stmt = (node) => everyStmtChild(node, expr, stmt);
-    for (const fn of mod.functions) {
-        if (!fn.body.every(stmt))
-            break;
-    }
-    return found;
-}
-/** 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 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",
-    "process.stdoutWrite",
-    "process.stderrWrite",
-    "process.stdoutWriteBytes",
-    "process.stderrWriteBytes",
-    "procStream.write",
-    "weakMap.new",
-    "weakSet.new",
-    "dyn.fromEntries",
-    "bytes.constructor",
-    "bytes.instanceOf",
-    "buffer.byteLenDyn",
-    "bytes.construct",
-    "arrayBuffer.new",
-    "arrayBuffer.byteLengthGetter",
-    "arrayBuffer.viewU8C",
-    "arrayBuffer.viewI8",
-    "arrayBuffer.viewU16",
-    "arrayBuffer.viewI16",
-    "arrayBuffer.viewU8",
-    "arrayBuffer.viewU32",
-    "arrayBuffer.viewI32",
-    "arrayBuffer.viewF32",
-    "arrayBuffer.viewF64",
-    "arrayBuffer.viewDV",
-    "bytes.bufferSource",
-    "text.decodeBufferSource",
-    "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.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);
-    // the subscribe/unsubscribe forms throw Node's ERR_INVALID_ARG_TYPE for
-    // non-function subscribers.
-    "dc.publish",
-    "dc.subscribe",
-    "dc.unsubscribe",
-    "dc.chanSubscribe",
-    "dc.chanUnsubscribe",
-    "dc.tcSubscribe",
-    "dc.tcUnsubscribe",
-    "dc.tcTraceSync",
-    "dc.tcTraceCallback",
-    "dc.tcTracePromise",
-    "process.onUncaughtException",
-    "process.offUncaughtException",
-    "process.onSignal",
-    "process.offSignal",
-    "process.onUnhandledRejection",
-    "process.onRejectionHandled",
-    "async.awaitDyn",
-    "als.run",
-    "als.exitRun",
-    "dc.chanBindStore",
-    "dc.chanRunStores",
-    "http.resWriteHeadDyn",
-    "http.resWriteContinue",
-    "http.resWriteProcessing",
-    "http.resWriteEarlyHints",
-    "http.validateHeaderName",
-    "http.validateHeaderValue",
-    "http.serverTimeoutGet",
-    "http.serverTimeoutOptionSet",
-    "net.sockSetEncoding",
-    "http.reqSetEncoding",
-    "fs.readFileSyncBuf",
-    "fs.readFileSyncDyn",
-    // tls/https runtime options records: the walks throw the catchable
-    // runtime fence for out-of-bounds members and non-PEM values (the
-    // divergence-66 stance).
-    "tls.pemDyn",
-    "tls.createServerDyn",
-    "tls.createSecureContextDyn",
-    "tls.caCertsChk",
-    "tls.createServerDynCb",
-    "https.createServerDyn",
-    "https.createServerDynCb",
-    "http2.createSecureServerDyn",
-    "http2.createSecureServerDynCb",
-    "tls.connect",
-    "tls.connectCb",
-    // The CA-store surface: an unknown getCACertificates type throws
-    // Node's ERR_INVALID_ARG_VALUE TypeError; setDefaultCACertificates
-    // throws Node's ERR_CRYPTO_OPERATION_FAILED on a certificate-free
-    // array.
-    "tlsca.get",
-    "tlsca.set",
-    // EventEmitter dispatch runs user listeners synchronously (emit), and
-    // the mutation forms fire the newListener/removeListener meta events —
-    // any of them can throw. emitError additionally THROWS its payload when
-    // 'error' has no listener, Node's unhandled-'error' contract.
-    "emitter.emit",
-    "emitter.emitFlex",
-    "emitter.emitError",
-    "emitter.on",
-    "emitter.off",
-    "emitter.checkListener",
-    "emitter.onDyn",
-    "emitter.onFlex",
-    "emitter.offDyn",
-    "emitter.onData",
-    "emitter.onDataDyn",
-    "emitter.emitData",
-    "readable.nextChunk",
-    "readable.nextChunkDyn",
-    // The checked-dynamic chunk forms throw Node's ERR_INVALID_ARG_TYPE
-    // chunk TypeError on a non-string/Buffer dyn kind.
-    "net.sockWriteDyn",
-    "net.sockEndDyn",
-    "http.resWriteDyn",
-    "http.resEndDyn",
-    "http.resAddTrailers",
-    "http.resFlushHeaders",
-    "http.resUncork",
-    "http.resWriteHead",
-    "http.resWriteHeadN",
-    "http.resWriteHeadPairs",
-    "http.resWrite",
-    "http.resWriteBytes",
-    "http.resEnd",
-    "http.resEndStr",
-    "http.resEndBytes",
-    "http.clientWriteDyn",
-    "http.clientEndDyn",
-    "http.clientAddTrailers",
-    "http.clientFlushHeaders",
-    "http.clientUncork",
-    "http.clientWrite",
-    "http.clientWriteBytes",
-    "http.clientEnd",
-    "http.clientEndStr",
-    "http.clientEndBytes",
-    // The URL-string client form throws catchably on an unparsable input
-    // ("Invalid URL") or a non-http scheme (ERR_INVALID_PROTOCOL).
-    "http.requestUrl",
-    "http.requestUrlCb",
-    // The h2 client's throwing entries: connect on a bad/non-http
-    // authority (ERR_INVALID_URL / ERR_INVALID_PROTOCOL), request on a
-    // closed/destroyed session (ERR_HTTP2_INVALID_SESSION), setEncoding on
-    // an unknown name (ERR_UNKNOWN_ENCODING). Event fires run user code
-    // synchronously (the stream-operations stance below), so the data/
-    // write paths that can fire inline join too.
-    "http2.connect",
-    "http2.connectCb",
-    "http2.sessionRequest",
-    "http2.streamSetEncoding",
-    "http2.streamRespond",
-    "http2.streamWrite",
-    "http2.streamWriteBytes",
-    "http2.streamEnd",
-    "http2.streamEndStr",
-    "http2.streamEndBytes",
-    "emitter.removeAll",
-    // Stream operations run user code synchronously (option callbacks and
-    // 'data'/'drain'/... listeners on the caller's stack, like emit) — any
-    // of them may leave a listener's throw pending. destroy with no 'error'
-    // listener throws the payload itself (the emitter.emitError contract).
-    // The dyn-options constructors walk the record at runtime: a consumed-
-    // but-unlowered option (objectMode, construct, ...) throws the compile
-    // fence's runtime twin; a bad encoding throws ERR_UNKNOWN_ENCODING.
-    "stream.finished",
-    "stream.finishedDyn",
-    "stream.pipeline",
-    "stream.pipelineDyn",
-    "sp.finished",
-    "sp.pipeline",
-    "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.pushStrEnc",
-    "readable.pushNull",
-    "readable.pushU",
-    "readable.pushDyn",
-    "readable.unshift",
-    "readable.unshiftStr",
-    "readable.read",
-    "readable.readDyn",
-    "stream.onDyn",
-    "readable.resume",
-    "readable.pipe",
-    "readable.unpipe",
-    "writable.write",
-    "writable.writeStr",
-    "writable.writeU",
-    "writable.writeDyn",
-    "writable.end",
-    "writable.uncork",
-    "stream.destroy",
-    "stream.destroyErr",
-    "stream.iteratorClose",
-    // setMaxListeners(n) throws Node's ERR_OUT_OF_RANGE RangeError for
-    // negative/NaN arguments; the static form's default-max write validates
-    // identically (Node's validateNumber(n, "setMaxListeners", 0)).
-    "emitter.setMax",
-    "emitter.setDefaultMax",
-    // The createConnection request forms run the caller's dialer closure
-    // synchronously — a throw there propagates like Node's.
-    "http.requestConn",
-    "http.requestConnCb",
-    "process.kill",
-    "process.killNum",
-    "process.setExitCode",
-    // cpuUsage(prev)'s field validation: negative/non-finite prev fields
-    // throw Node's ERR_INVALID_ARG_VALUE RangeError, catchably.
-    "process.cpuPrevValidate",
-    // Non-TTY stdin: Node's stdin has no setRawMode member, so the call is
-    // the exact catchable TypeError.
-    "process.stdinSetRawMode",
-    // The unguarded h2-only stream call: always throws Node's TypeError.
-    "http2.streamUndefCall",
-    "http.reqH2StreamOrThrow",
-    // A read of a declare-d const nothing defines: always throws Node's
-    // catchable ReferenceError.
-    "global.undefRead",
-    // The compiler-resolved Node-parity throw: always throws, catchably.
-    "error.nodeThrow",
-    // USVString coercion runs user toString/valueOf — throws propagate.
-    "dyn.toStringCoerce",
-    "dyn.stringConstructor",
-    "dyn.propertyKey",
-    "dyn.toNumeric",
-    "dyn.increment",
-    // 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",
-    // The caller's lookup runs synchronously inside the connect call — a
-    // throw there propagates like Node's.
-    "net.connectLookup",
-    "cp.execSync",
-    "cp.execCapture",
-    // The client request constructors validate the method token
-    // synchronously (Node's ClientRequest ctor throw:
-    // ERR_INVALID_HTTP_TOKEN).
-    "http.request",
-    "http.requestCb",
-    "http.requestConn",
-    "http.requestConnCb",
-    // The agent rows add the runtime agent-value gates (a non-Agent value
-    // is Node's ERR_INVALID_ARG_TYPE); agentNew's keepAlive: true throws
-    // the named pooling fence.
-    "http.agentNew",
-    "http.requestAgent",
-    "http.requestAgentCb",
-    "https.requestAgent",
-    "https.requestAgentCb",
-    "https.request",
-    "https.requestCb",
-    // The URL-string form's parse, exactly http.requestUrl's (an
-    // unparsable input, or a scheme that is not https).
-    "https.requestUrl",
-    "https.requestUrlCb",
-    "https.requestFn",
-    "https.requestFnCb",
-    "rl.question",
-    "island.eval",
-    "island.import",
-    "island.castFail",
-    "json.parse",
-    "json.parseReviver",
-    "json.stringifyReplacer",
-    "json.stringifyValue",
-    "date.nativeNew",
-    "date.checkedValue",
-    "util.parseArgs",
-    "util.parseEnv",
-    "util.getSystemErrorName",
-    "util.getSystemErrorMessage",
-    "util.stripVTControlCharacters",
-    "util.isDeepStrictEqual",
-    "util.styleText",
-    "util.toUSVString",
-    // 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].
-    "str.atob",
-    "str.btoa",
-    "str.b64Missing",
-    // queueMicrotask's checked-dynamic form throws ERR_INVALID_ARG_TYPE
-    // synchronously on a non-function argument (the closure form never
-    // throws — the callback's own throw surfaces at drain, uncaught).
-    "timers.queueMicrotaskDyn",
-    // structuredClone: option validation throws Node's TypeErrors,
-    // functions/handles the spec's DataCloneError, cycles the scriptc
-    // fence; the zero-argument form always throws ERR_MISSING_ARGS. The
-    // DOMException clone shares the option validation.
-    "dyn.structuredClone",
-    "dyn.cloneMissing",
-    "dyn.cloneTransferFail",
-    // the dyn Object walks throw on null/undefined receivers
-    "dyn.objKeys",
-    "dyn.forInKeys",
-    "dyn.hasOwn",
-    "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",
-    "dyn.packPushSpreadIter",
-    "dyn.assignAll",
-    "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",
-    "error.domClone",
-    // 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",
-    "dyn.hasOwnComputed",
-    "dyn.propertyIsEnumerableComputed",
-    // the destructuring pack throws V8's TypeError on non-iterable dyn kinds
-    "dyn.iterPack",
-    "dyn.arrayFromIterator",
-    "dyn.iterator",
-    "dyn.iteratorResult",
-    "dyn.mapSeedEntries",
-    "dyn.mapSeedEntry",
-    "dyn.freeze",
-    "dyn.isFrozen",
-    "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",
-    "fs.writeFileSync",
-    "fs.appendFileSync",
-    "fs.mkdirSync",
-    "fs.rmSync",
-    "fs.rmdirSync",
-    "fs.readdirSync",
-    "fs.readdirTypesSync",
-    "url.new",
-    "url.newBase",
-    "url.set",
-    "url.setChecked",
-    "url.fileURLToPathUrl",
-    "url.fileURLToPathChecked",
-    "url.fileURLToPathOptions",
-    "url.fileURLToPathBuffer",
-    "url.pathToFileURLChecked",
-    "url.fileURLToPathStr",
-    // The win32-target flavor of pathToFileURL (same runtime entry point —
-    // the bridge dispatches by the binary's platform): Node's win32 arm
-    // raises ERR_INVALID_ARG_VALUE TypeErrors for malformed UNC inputs, so
-    // only THIS flavor seeds may-throw — posix emission stays untouched.
-    "url.pathToFileURLWin32",
-    "url.pathToFileURLPlatform",
-    // URLSearchParams from a string[][]: Node's ERR_INVALID_TUPLE TypeError
-    // 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",
-    "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",
-    "crypto.hkdf",
-    "crypto.hkdfCb",
-    "crypto.scrypt",
-    "crypto.scryptCb",
-    "buffer.concat",
-    "buffer.concatLen",
-    "buffer.fromDyn",
-    // The checked-dynamic compare/equals validators: Node's argument
-    // ladders throw ERR_INVALID_ARG_TYPE / ERR_OUT_OF_RANGE catchably.
-    "buffer.compareChk",
-    "bytes.equalsChk",
-    "bytes.compareChk",
-    "buffer.newStringFail",
-    "fs.toUnixTimestamp",
-    "fs.existsChk",
-    "fs.mkdtempChk",
-    "fs.mkdtempSyncChk",
-    "fs.readFileChk",
-    "fs.opendirChk",
-    "fs.watchFileChk",
-    "fs.lchmodChk",
-    "fs.lchmodSyncChk",
-    "fsp.lchmodChk",
-    "fs.readChk",
-    "fs.streamOptsChk",
-    "net.connectAttempt",
-    "net.connectOptsChk",
-    "net.setAutoSelTimeout",
-    "error.argTypeThrow",
-    "error.propTypeThrow",
-    "emitter.setMaxChk",
-    "emitter.setDefaultMaxChk",
-    "fs.readFileSyncBytes",
-    "fs.writeFileSyncBytes",
-    "fs.appendFileSyncBytes",
-    "zlib.inflateSync",
-    "zlib.inflateRawSync",
-    "zlib.gunzipSync",
-    "zlib.unzipSync",
-    "zlib.crc32",
-    "date.toISOString",
-    "date.toISOStringValue",
-    "fs.mkdirRecursiveSync",
-    "fs.rmOptsSync",
-    "fs.rmRetrySync",
-    "fs.mkdtempSync",
-    "fs.accessSync",
-    "fs.readFdSync",
-    "fs.readFdSyncBytes",
-    // node:dgram state errors (Node throws synchronously): bind on a bound
-    // socket, connect on a connected one, send/close/address on a closed or
-    // never-bound one.
-    "dgram.bind",
-    "dgram.bindCb",
-    "dgram.connect",
-    "dgram.connectCb",
-    "dgram.sendStr",
-    "dgram.sendBytes",
-    "dgram.sendChk",
-    "dgram.address",
-    "dgram.close",
-    "dgram.closeCb",
-    // The assert surface: every entry point except sameValue, bytesDeepEq,
-    // and the shape accumulator's begin/slot/test calls throws the
-    // catchable AssertionError on failure.
-    "assert.ok",
-    "assert.eqF64",
-    "assert.eqBigInt",
-    "assert.eqStr",
-    "assert.eqBool",
-    "assert.eqSym",
-    "assert.eqDyn",
-    "assert.looseResult",
-    "assert.deepResult",
-    "assert.match",
-    "assert.refEqBytes",
-    "assert.refEqFn",
-    "assert.throwsNone",
-    "assert.throwsMismatch",
-    "assert.throwsRegex",
-    "assert.shapeEnd",
-    "assert.unwantedRejection",
-    "assert.unwantedError",
-    "assert.noErrorPredicate",
-    "assert.regexDynTest",
-    "assert.expectsErrDyn",
-    "assert.ifErrorErr",
-    "assert.ifErrorF64",
-    "assert.ifErrorStr",
-    "assert.ifErrorBool",
-    "assert.ifErrorDyn",
-    // util.inspect of an island `any` composite: the runtime tag is all
-    // there is, so the honest answer is a catchable TypeError.
-    "insp.jsval",
-    // The wider sync fs slice: same catchable errno throws as the rest.
-    "fs.unlinkSync",
-    "fs.chmodSync",
-    "fs.chownSync",
-    "fs.copyFileSync",
-    "fs.renameSync",
-    "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.writeFileModeSync",
-    "fs.mkdirModeSync",
-    "fs.mkdirRecursiveModeSync",
-    "fs.openSync",
-    "fs.openNumericSync",
-    "fs.readSync",
-    "fs.writeSync",
-    "fs.writeStrSync",
-    "fs.closeSync",
-    "fs.watch",
-    "fs.watchCb",
-    "crypto.x509Fingerprint",
-    "crypto.x509FingerprintStr",
-    "crypto.x509ValidFrom",
-    "crypto.x509ValidFromStr",
-    "crypto.x509ValidTo",
-    "crypto.x509ValidToStr",
-]);
 //# sourceMappingURL=ir.js.map