@scriptc/compiler 0.1.7 → 0.2.1

package/dist/ir/validate.js

@@ -1,5 +1,7 @@
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionContainerArmsOk, URL_T, VOID } from "./ir.js";
 import { BIGINT_T } from "./ir.js";
+import { unionWideningTags } from "./analysis.js";
+import { alwaysReturns } from "./control-flow.js";
 /** Per-method signature for strIntrinsic: `argTypes` lists every argument
  * position (optional ones included); `minArgs` is how many may be omitted
  * from the end (backends fill the documented defaults). Exported for the
@@ -38,11 +40,14 @@ export const REGEX_INTRINSIC_SIGS = {
     // VOID here is the process.envGet sentinel; the regexIntrinsic case
     // checks the union's arms.
     match: { receiver: STRING, argTypes: [REGEX], result: VOID },
+    exec: { receiver: STRING, argTypes: [REGEX], result: VOID },
+    lastIndex: { receiver: REGEX, argTypes: [], result: F64 },
     matchAll: { receiver: STRING, argTypes: [REGEX], result: arrayOf(arrayOf(STRING)) },
     matchAllInto: { receiver: STRING, argTypes: [REGEX, arrayOf(F64)], result: arrayOf(arrayOf(STRING)) },
     search: { receiver: STRING, argTypes: [REGEX], result: F64 },
     source: { receiver: REGEX, argTypes: [], result: STRING },
     flags: { receiver: REGEX, argTypes: [], result: STRING },
+    toString: { receiver: REGEX, argTypes: [], result: STRING },
     replace: { receiver: STRING, argTypes: [REGEX, STRING], result: STRING },
     replaceAll: { receiver: STRING, argTypes: [REGEX, STRING], result: STRING },
     split: { receiver: STRING, argTypes: [REGEX, F64], result: arrayOf(STRING) },
@@ -57,6 +62,11 @@ export const REGEX_INTRINSIC_SIGS = {
 export const LIB_FN_SIGS = {
     "fetch.start": { argTypes: [STRING, DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseNew": { argTypes: [DYN, DYN], result: DYN },
+    "fetch.input": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "fetch.function": { argTypes: [], result: DYN },
+    "fetch.requestNew": { argTypes: [DYN, DYN], result: DYN },
+    "fetch.headersNew": { argTypes: [DYN], result: DYN },
+    "fetch.responseArrayBuffer": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseJson": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseText": { argTypes: [DYN], result: { kind: "promise", inner: STRING } },
     "fetch.responseBytes": { argTypes: [DYN], result: { kind: "promise", inner: BYTES_U8 } },
@@ -68,6 +78,8 @@ export const LIB_FN_SIGS = {
     // Program-dependent iterable: typed arrays/bytes/string stay intact so
     // the native stream can pull lazily; checked-dynamic values are the
     // fallback. The libCall validator below checks the closed set.
+    "fetch.webIs": { argTypes: [DYN, STRING], result: BOOL },
+    "fetch.streamIs": { argTypes: [DYN], result: BOOL },
     "fetch.streamFrom": { argTypes: [null], result: DYN },
     // The chunk/result record depends on ReadableStream<T>; validated below.
     "fetch.readerRead": { argTypes: [DYN], result: VOID },
@@ -78,13 +90,46 @@ export const LIB_FN_SIGS = {
     // checked in the libCall case, like error.new.
     "island.castFail": { argTypes: [JSVAL, STRING], result: VOID },
     "json.parse": { argTypes: [STRING], result: DYN },
+    "json.parseReviver": { argTypes: [STRING, DYN], result: DYN },
+    "json.stringifyReplacer": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "json.stringifyValue": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.keySet": { argTypes: [DYN, STRING, DYN], result: VOID },
+    "dyn.keySetComputed": { argTypes: [DYN, DYN, DYN], result: VOID },
+    "dyn.keyDelete": { argTypes: [DYN, STRING, BOOL], result: VOID },
+    "dyn.keyDeleteComputed": { argTypes: [DYN, DYN, BOOL], result: VOID },
+    "dyn.hasKeyComputed": { argTypes: [DYN, DYN], result: BOOL },
+    "dyn.hasOwnComputed": { argTypes: [DYN, DYN], result: BOOL },
+    "dyn.propertyIsEnumerableComputed": { argTypes: [DYN, DYN], result: BOOL },
+    "dyn.globalSymbolGet": { argTypes: [SYMBOL_T], result: DYN },
+    "dyn.globalSymbolSet": { argTypes: [SYMBOL_T, DYN], result: VOID },
+    "dyn.globalSymbolHas": { argTypes: [SYMBOL_T], result: BOOL },
+    "dyn.globalSymbolDelete": { argTypes: [SYMBOL_T], result: VOID },
+    "dyn.typedRefIs": { argTypes: [DYN, STRING], result: BOOL },
+    "dyn.classIs": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.iterPack": { argTypes: [DYN, STRING], result: DYN },
+    "dyn.arrayFromIterator": { argTypes: [DYN], result: DYN },
+    "dyn.iterator": { argTypes: [DYN, STRING], result: DYN },
+    "dyn.iteratorResult": { argTypes: [DYN], result: DYN },
+    "dyn.mapSeedEntries": { argTypes: [DYN], result: DYN },
+    "dyn.mapSeedEntry": { argTypes: [DYN], result: DYN },
     "dyn.arrLen": { argTypes: [DYN], result: F64 },
     "dyn.arrAt": { argTypes: [DYN, F64], result: DYN },
     "dyn.hasKey": { argTypes: [DYN, STRING], result: BOOL },
-    "dyn.toString": { argTypes: [DYN, STRING, STRING], result: STRING },
+    "dyn.freeze": { argTypes: [DYN], result: DYN },
+    "dyn.isFrozen": { argTypes: [DYN], result: BOOL },
+    "dyn.nativeSetNew": { argTypes: [DYN], result: DYN },
+    "dyn.nativeSetIs": { argTypes: [DYN], result: BOOL },
+    "dyn.nativeMapIs": { argTypes: [DYN], result: BOOL },
+    "dyn.nativeUrlIs": { argTypes: [DYN], result: BOOL },
+    "dyn.nativeDateIs": { argTypes: [DYN], result: BOOL },
+    "date.nativeNew": { argTypes: [DYN], result: DYN },
+    "date.checkedValue": { argTypes: [DYN], result: DATE_T },
+    "dyn.nativeRegexIs": { argTypes: [DYN], result: BOOL },
+    "dyn.toString": { argTypes: [DYN, DYN, STRING], result: STRING },
     "dyn.defineProps": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.defineProperty": { argTypes: [DYN, DYN, DYN], result: DYN },
+    "dyn.getOwnPropertyDescriptor": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.arrayProtoCall": { argTypes: [DYN, STRING, DYN], result: DYN },
     "dyn.typeof": { argTypes: [DYN], result: STRING },
     "dyn.objectTag": { argTypes: [DYN], result: STRING },
     "module.registryInit": { argTypes: [F64], result: VOID },
@@ -139,8 +184,8 @@ export const LIB_FN_SIGS = {
     // Signal listeners are zero-param (the ambient shape); exit/stdin
     // callbacks carry program-dependent one-param shapes — null slots, the
     // libCall case checks them (child.onExit precedent).
-    "process.onSignal": { argTypes: [F64, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "process.offSignal": { argTypes: [F64, { kind: "func", params: [], ret: VOID }], result: VOID },
+    "process.onSignal": { argTypes: [STRING, DYN, BOOL], result: VOID },
+    "process.offSignal": { argTypes: [STRING, DYN], result: VOID },
     "process.onExit": { argTypes: [null, BOOL], result: VOID },
     "process.offExit": { argTypes: [null], result: VOID },
     "stdin.onData": { argTypes: [null, BOOL], result: VOID },
@@ -188,6 +233,7 @@ export const LIB_FN_SIGS = {
     "net.getAutoSelTimeout": { argTypes: [], result: F64 },
     "net.setAutoSelTimeout": { argTypes: [F64], result: VOID },
     "fs.realpathSync": { argTypes: [STRING], result: STRING },
+    "fs.realpathNativeSync": { argTypes: [STRING], result: STRING },
     "os.userName": { argTypes: [], result: STRING },
     "os.userShell": { argTypes: [], result: STRING },
     "os.userHomedir": { argTypes: [], result: STRING },
@@ -243,16 +289,19 @@ export const LIB_FN_SIGS = {
     "str.btoa": { argTypes: [DYN], result: STRING },
     "str.b64Missing": { argTypes: [], result: STRING },
     "str.decodeUriComponent": { argTypes: [STRING], result: STRING },
+    "str.decodeUri": { argTypes: [STRING], result: STRING },
     "str.encodeUri": { argTypes: [STRING], result: STRING },
     "regexp.escape": { argTypes: [STRING], result: STRING },
     "num.toExponential": { argTypes: [F64], result: STRING },
     "num.toFixed0": { argTypes: [F64], result: STRING },
     "num.toFixed": { argTypes: [F64, F64], result: STRING },
+    "num.toStringRadix": { argTypes: [F64, DYN], result: STRING },
     "num.sameValue": { argTypes: [F64, F64], result: BOOL },
     "intl.numFormatEnUs": { argTypes: [F64], result: STRING },
     "sym.new": { argTypes: [STRING], result: SYMBOL_T },
     "sym.newAnon": { argTypes: [], result: SYMBOL_T },
     "sym.for": { argTypes: [STRING], result: SYMBOL_T },
+    "sym.wellKnown": { argTypes: [STRING], result: SYMBOL_T },
     // Result is the interned `string | undefined` union — the libCall case
     // checks the arms (the spawnRes.error pattern).
     "sym.keyFor": { argTypes: [SYMBOL_T], result: VOID },
@@ -288,6 +337,7 @@ export const LIB_FN_SIGS = {
     "bigint.dataViewGet": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: BIGINT_T },
     "bigint.dataViewSet": { argTypes: [BYTES_U8, F64, BIGINT_T, BOOL], result: VOID },
     "url.new": { argTypes: [STRING], result: URL_T },
+    "url.newBase": { argTypes: [STRING, STRING], result: URL_T },
     "url.protocol": { argTypes: [URL_T], result: STRING },
     "url.origin": { argTypes: [URL_T], result: STRING },
     "url.username": { argTypes: [URL_T], result: STRING },
@@ -298,10 +348,13 @@ export const LIB_FN_SIGS = {
     "url.pathname": { argTypes: [URL_T], result: STRING },
     "url.href": { argTypes: [URL_T], result: STRING },
     "url.fileURLToPathUrl": { argTypes: [URL_T], result: STRING },
+    "url.fileURLToPathChecked": { argTypes: [DYN], result: STRING },
     "url.fileURLToPathStr": { argTypes: [STRING], result: STRING },
     "url.pathToFileURL": { argTypes: [STRING], result: URL_T },
+    "url.pathToFileURLPlatform": { argTypes: [STRING, BOOL], result: URL_T },
     "url.pathToFileURLWin32": { argTypes: [STRING], result: URL_T },
     "sp.new": { argTypes: [], result: SEARCH_PARAMS_T },
+    "sp.newChecked": { argTypes: [DYN], result: SEARCH_PARAMS_T },
     "sp.parse": { argTypes: [STRING], result: SEARCH_PARAMS_T },
     "sp.copy": { argTypes: [SEARCH_PARAMS_T], result: SEARCH_PARAMS_T },
     // The pairs argument is string[][] — checked structurally below (the
@@ -815,6 +868,8 @@ export const LIB_FN_SIGS = {
     "child.disconnect": { argTypes: [CHILD_T], result: VOID },
     "child.onMessage": { argTypes: [CHILD_T, null, BOOL], result: VOID },
     "child.onDisconnect": { argTypes: [CHILD_T, null, BOOL], result: VOID },
+    "child.onSpawn": { argTypes: [CHILD_T, null], result: VOID },
+    "child.onDyn": { argTypes: [CHILD_T, STRING, DYN], result: VOID },
     "process.connected": { argTypes: [], result: BOOL },
     "process.send": { argTypes: [STRING], result: BOOL },
     "process.sendCb": { argTypes: [STRING, null], result: BOOL },
@@ -829,6 +884,7 @@ export const LIB_FN_SIGS = {
         argTypes: [STRING, arrayOf(STRING), F64, F64, F64, F64, F64, BOOL, BOOL, BOOL, arrayOf(STRING), STRING],
         result: CHILD_T,
     },
+    "cp.spawnDynamic": { argTypes: [STRING, arrayOf(STRING), DYN], result: CHILD_T },
     // The callback's func type is program-dependent (zero params, or the
     // `number | null` union / the %Error class) — the libCall case checks
     // the shape; the slot here only pins arity and the child receiver.
@@ -880,6 +936,7 @@ export const LIB_FN_SIGS = {
     "child.kill": { argTypes: [CHILD_T, STRING], result: BOOL },
     "child.killNum": { argTypes: [CHILD_T, F64], result: BOOL },
     "child.unref": { argTypes: [CHILD_T], result: VOID },
+    "child.ref": { argTypes: [CHILD_T], result: VOID },
     "spawnRes.stdout": { argTypes: [SPAWNRES_T], result: STRING },
     "spawnRes.stderr": { argTypes: [SPAWNRES_T], result: STRING },
     "crypto.randomUUID": { argTypes: [], result: STRING },
@@ -887,6 +944,7 @@ export const LIB_FN_SIGS = {
     "crypto.randomBytes": { argTypes: [F64], result: BYTES_U8 },
     "crypto.hashDigestStr": { argTypes: [STRING, STRING, STRING], result: STRING },
     "crypto.hashDigestBytes": { argTypes: [STRING, BYTES_U8, STRING], result: STRING },
+    "crypto.native": { argTypes: [], result: DYN },
     "crypto.hashNew": { argTypes: [STRING], result: CRYPTOHASH_T },
     "crypto.hmacNewStr": { argTypes: [STRING, STRING], result: CRYPTOHMAC_T },
     "crypto.hmacNewBytes": { argTypes: [STRING, BYTES_U8], result: CRYPTOHMAC_T },
@@ -909,7 +967,10 @@ export const LIB_FN_SIGS = {
     // The Buffer statics and the fs/zlib Buffer forms: fixed always-u8
     // signatures (Buffer IS a Uint8Array — one bytes kind).
     "buffer.fromStr": { argTypes: [STRING, STRING], result: BYTES_U8 },
+    "buffer.brand": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "buffer.fromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
     "buffer.concat": { argTypes: [arrayOf(BYTES_U8)], result: BYTES_U8 },
+    "buffer.byteLenDyn": { argTypes: [DYN, STRING], result: F64 },
     "buffer.byteLenStr": { argTypes: [STRING, STRING], result: F64 },
     "buffer.isEncoding": { argTypes: [STRING], result: BOOL },
     "buffer.concatLen": { argTypes: [arrayOf(BYTES_U8), F64], result: BYTES_U8 },
@@ -937,10 +998,12 @@ export const LIB_FN_SIGS = {
     "emitter.setDefaultMaxChk": { argTypes: [DYN, STRING], result: VOID },
     "fs.readFileSyncBytes": { argTypes: [STRING], result: BYTES_U8 },
     "fs.writeFileSyncBytes": { argTypes: [STRING, BYTES_U8], result: VOID },
+    "fs.appendFileSyncBytes": { argTypes: [STRING, BYTES_U8], result: VOID },
     "fsp.readFileBytes": { argTypes: [STRING], result: { kind: "promise", inner: BYTES_U8 } },
     "zlib.deflateSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "zlib.inflateSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "zlib.deflateRawSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.deflateLevelSync": { argTypes: [BYTES_U8, F64, F64], result: BYTES_U8 },
     "zlib.inflateRawSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "zlib.gzipSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "zlib.gunzipSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
@@ -1006,30 +1069,63 @@ export const LIB_FN_SIGS = {
     "process.cwd": { argTypes: [], result: STRING },
     "process.pid": { argTypes: [], result: F64 },
     "dyn.this": { argTypes: [], result: DYN },
+    "dyn.generatorThis": { argTypes: [], result: DYN },
     "process.getuid": { argTypes: [], result: F64 },
     "process.getgid": { argTypes: [], result: F64 },
     "process.execPath": { argTypes: [], result: STRING },
     "process.arch": { argTypes: [], result: STRING },
+    "process.versions": { argTypes: [], result: DYN },
+    "process.builtinId": { argTypes: [DYN, arrayOf(STRING)], result: STRING },
+    "process.builtinModule": { argTypes: [STRING, DYN], result: DYN },
+    "process.builtinUnsupported": { argTypes: [STRING, STRING], result: DYN },
+    "fs.callbackValue": { argTypes: [STRING], result: DYN },
+    "fs.callbackCall": { argTypes: [STRING, DYN], result: DYN },
+    "process.hrtimeValue": { argTypes: [], result: DYN },
     "process.versionsNode": { argTypes: [], result: STRING },
     "process.versionsOpenssl": { argTypes: [], result: STRING },
     "process.kill": { argTypes: [F64, STRING], result: BOOL },
     "process.killNum": { argTypes: [F64, F64], result: BOOL },
     "process.stdoutWrite": { argTypes: [STRING], result: BOOL },
+    "process.stdio": { argTypes: [F64], result: DYN },
     "process.stderrWrite": { argTypes: [STRING], result: BOOL },
     // error.new's result and the receiver slots are builtin-error classes —
     // program-dependent object types, checked in the libCall case.
     "error.new": { argTypes: [STRING], result: VOID },
+    "error.newOptions": { argTypes: [DYN, DYN], result: VOID },
+    "error.ctorOptions": { argTypes: [null, DYN, DYN], result: VOID },
+    "error.cause": { argTypes: [null], result: DYN },
+    "error.hasCause": { argTypes: [null], result: BOOL },
+    "error.setCause": { argTypes: [null, DYN], result: VOID },
+    "error.defineCause": { argTypes: [null, DYN], result: VOID },
+    "error.deleteCause": { argTypes: [null], result: VOID },
     "error.nodeThrow": { argTypes: [F64, STRING, STRING], result: VOID },
     "dyn.toStringCoerce": { argTypes: [DYN], result: STRING },
+    "dyn.stringConstructor": { argTypes: [DYN], result: STRING },
+    "dyn.propertyKey": { argTypes: [DYN], result: DYN },
+    "dyn.toNumeric": { argTypes: [DYN], result: DYN },
+    "dyn.increment": { argTypes: [DYN, BOOL], result: DYN },
+    "dyn.numberConstructor": { argTypes: [DYN], result: F64 },
+    "dyn.bigintConstructor": { argTypes: [DYN], result: BIGINT_T },
     "dyn.toNumberCoerce": { argTypes: [DYN], result: F64 },
+    "dyn.add": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.arithmetic": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "dyn.compare": { argTypes: [DYN, DYN, STRING], result: BOOL },
+    "dyn.bitwise": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "dyn.proxyNew": { argTypes: [DYN, DYN], result: DYN },
     // Always throws; the result is the READ's declared type (a typed dummy
     // the unwind abandons) — the libCall case skips the result check.
     "global.undefRead": { argTypes: [STRING], result: VOID },
+    "console.native": { argTypes: [], result: DYN },
+    "global.native": { argTypes: [arrayOf(STRING)], result: DYN },
     // `X.name` through a class value: the arg is a program-dependent
     // classval (a null slot; the libCall case checks the kind).
     "class.name": { argTypes: [null], result: STRING },
     "error.ctor": { argTypes: [null, STRING], result: VOID },
     "error.toString": { argTypes: [null], result: STRING },
+    "dyn.sameValue": { argTypes: [DYN, DYN], result: BOOL },
+    "error.stack": { argTypes: [null], result: STRING },
+    "error.stackLimitGet": { argTypes: [], result: F64 },
+    "error.stackLimitSet": { argTypes: [F64], result: VOID },
     // Receiver (any error-hierarchy object) and the program-dependent
     // `string | undefined` result are checked in the libCall case.
     "error.code": { argTypes: [null], result: VOID },
@@ -1044,20 +1140,77 @@ export const LIB_FN_SIGS = {
     "error.domCause": { argTypes: [null], result: DYN },
     "error.domClone": { argTypes: [null, DYN], result: VOID },
     "dyn.errInstanceof": { argTypes: [DYN, F64], result: BOOL },
+    "weakMap.is": { argTypes: [DYN], result: BOOL },
+    "weakSet.is": { argTypes: [DYN], result: BOOL },
+    "weakMap.new": { argTypes: [DYN], result: DYN },
+    "weakSet.new": { argTypes: [DYN], result: DYN },
+    "dyn.fromEntries": { argTypes: [DYN], result: DYN },
+    "bytes.constructor": { argTypes: [STRING], result: DYN },
+    "bytes.instanceOf": { argTypes: [DYN, DYN], result: BOOL },
+    "bytes.construct": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "dyn.dataViewIs": { argTypes: [DYN], result: BOOL },
+    "dyn.construct": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "arrayBuffer.constructor": { argTypes: [], result: DYN },
+    "arrayBuffer.new": { argTypes: [DYN], result: DYN },
+    "ffi.argument": { argTypes: [DYN, STRING], result: DYN },
+    "ffi.memoryModule": { argTypes: [DYN], result: DYN },
+    "intl.segmenterNew": { argTypes: [], result: DYN },
+    "arrayBuffer.is": { argTypes: [DYN], result: BOOL },
+    "arrayBuffer.isView": { argTypes: [DYN], result: BOOL },
+    "arrayBuffer.byteLengthGetter": { argTypes: [], result: F64 },
+    "arrayBuffer.byteLengthDescriptor": { argTypes: [DYN], result: DYN },
+    "arrayBuffer.viewU8C": { argTypes: [DYN, DYN, DYN], result: bytesOf("u8c") },
+    "arrayBuffer.viewI8": { argTypes: [DYN, DYN, DYN], result: bytesOf("i8") },
+    "arrayBuffer.viewU16": { argTypes: [DYN, DYN, DYN], result: bytesOf("u16") },
+    "arrayBuffer.viewI16": { argTypes: [DYN, DYN, DYN], result: bytesOf("i16") },
+    "arrayBuffer.viewU8": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
+    "arrayBuffer.viewU32": { argTypes: [DYN, DYN, DYN], result: bytesOf("u32") },
+    "arrayBuffer.viewI32": { argTypes: [DYN, DYN, DYN], result: bytesOf("i32") },
+    "arrayBuffer.viewF32": { argTypes: [DYN, DYN, DYN], result: bytesOf("f32") },
+    "arrayBuffer.viewF64": { argTypes: [DYN, DYN, DYN], result: bytesOf("f64") },
+    "arrayBuffer.viewDV": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
     "dyn.objKeys": { argTypes: [DYN], result: DYN },
+    "dyn.forInKeys": { argTypes: [DYN], result: DYN },
     "dyn.hasOwn": { argTypes: [DYN, STRING], result: BOOL },
+    "dyn.propertyIsEnumerable": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.assign": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.copyDataProperties": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.objectRest": { argTypes: [DYN, DYN], result: DYN },
     "dyn.packPush": { argTypes: [DYN, DYN], result: VOID },
     "dyn.packPushSpread": { argTypes: [DYN, DYN, STRING], result: VOID },
     "dyn.packPushSpreadIter": { argTypes: [DYN, DYN], result: VOID },
+    "dyn.reflectApply": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.assignAll": { argTypes: [DYN, DYN], result: DYN },
     "dyn.objCreateNullProto": { argTypes: [], result: DYN },
+    "dyn.arrayPrototype": { argTypes: [], result: DYN },
+    "dyn.objectPrototype": { argTypes: [], result: DYN },
+    "dyn.functionApply": { argTypes: [], result: DYN },
+    "dyn.builtinMethod": { argTypes: [STRING, STRING], result: DYN },
+    "dyn.classPrototype": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.classBasePrototype": { argTypes: [DYN], result: DYN },
+    "dyn.classInherit": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.classSuper": { argTypes: [DYN, DYN, DYN], result: VOID },
+    "dyn.assignPrototype": { argTypes: [DYN, DYN, DYN], result: DYN },
+    "dyn.objCreate": { argTypes: [DYN], result: DYN },
+    "dyn.objCreateWithProperties": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.getPrototype": { argTypes: [DYN], result: DYN },
+    "dyn.setPrototype": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.getOwnPropertyNames": { argTypes: [DYN], result: DYN },
+    "dyn.ownKeys": { argTypes: [DYN], result: DYN },
+    "dyn.getOwnPropertySymbols": { argTypes: [DYN], result: DYN },
+    "dyn.getOwnPropertyDescriptors": { argTypes: [DYN], result: DYN },
+    "dyn.preventExtensions": { argTypes: [DYN], result: DYN },
+    "dyn.isExtensible": { argTypes: [DYN], result: BOOL },
+    "dyn.seal": { argTypes: [DYN], result: DYN },
+    "dyn.isSealed": { argTypes: [DYN], result: BOOL },
     "dyn.objValues": { argTypes: [DYN], result: DYN },
     "dyn.objEntries": { argTypes: [DYN], result: DYN },
     "dyn.structuredClone": { argTypes: [DYN, DYN], result: DYN },
     "dyn.cloneMissing": { argTypes: [], result: DYN },
     "dyn.cloneTransferFail": { argTypes: [], result: DYN },
     "regex.new": { argTypes: [STRING, STRING], result: REGEX },
+    "regex.resetLastIndex": { argTypes: [REGEX, F64], result: VOID },
+    "regex.newChecked": { argTypes: [DYN, DYN], result: REGEX },
     // node:events EventEmitter: receivers are emitter-hierarchy objects and
     // the chaining forms (on/off/removeAll/setMax) return the receiver's
     // own class — program-dependent object types, checked in the libCall
@@ -1082,6 +1235,7 @@ export const LIB_FN_SIGS = {
     "emitter.emitError": { argTypes: [null, STRING, null], result: BOOL },
     "emitter.count": { argTypes: [null, STRING], result: F64 },
     "emitter.countFn": { argTypes: [null, STRING, null], result: F64 },
+    "emitter.countDyn": { argTypes: [null, STRING, DYN], result: F64 },
     "emitter.names": { argTypes: [null], result: VOID },
     "emitter.listeners": { argTypes: [null, STRING], result: VOID },
     "emitter.onData": { argTypes: [null, STRING, null, BOOL, BOOL], result: VOID },
@@ -1143,6 +1297,8 @@ export const LIB_FN_SIGS = {
     "readable.pushDyn": { argTypes: [null, DYN], result: BOOL },
     "readable.unshift": { argTypes: [null, BYTES_U8], result: VOID },
     "readable.unshiftStr": { argTypes: [null, STRING], result: VOID },
+    "stream.onDyn": { argTypes: [null, STRING, DYN, BOOL, BOOL], result: VOID },
+    "readable.readDyn": { argTypes: [null, DYN], result: DYN },
     "readable.read": { argTypes: [null, F64], result: VOID },
     "readable.pause": { argTypes: [null], result: VOID },
     "readable.setEncoding": { argTypes: [null, STRING], result: VOID },
@@ -1269,6 +1425,8 @@ export const LIB_FN_SIGS = {
     "dc.tcTraceSync": { argTypes: [F64, DYN, DYN, DYN, DYN], result: DYN },
     "dc.tcTraceCallback": { argTypes: [F64, DYN, F64, DYN, DYN, DYN], result: DYN },
     "dc.tcTracePromise": { argTypes: [F64, DYN, DYN, DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "process.onUncaughtException": { argTypes: [DYN, BOOL, BOOL], result: VOID },
+    "process.offUncaughtException": { argTypes: [DYN, BOOL], result: VOID },
     "process.onUnhandledRejection": { argTypes: [DYN, BOOL], result: VOID },
     "process.offUnhandledRejection": { argTypes: [DYN], result: VOID },
     "process.onRejectionHandled": { argTypes: [DYN, BOOL], result: VOID },
@@ -1320,7 +1478,13 @@ export const LIB_FN_SIGS = {
     "date.parseGetTime": { argTypes: [STRING], result: F64 },
     "date.utc": { argTypes: [F64, F64, F64, F64, F64, F64, F64], result: F64 },
     "text.decode": { argTypes: [BYTES_U8], result: STRING },
+    "bytes.bufferSource": { argTypes: [DYN], result: BYTES_U8 },
+    "text.decodeBufferSource": { argTypes: [DYN], result: STRING },
+    "text.decodeOptions": { argTypes: [BYTES_U8, BOOL, BOOL], result: STRING },
+    "text.decodeStream": { argTypes: [DYN, BYTES_U8, F64, BOOL, BOOL, BOOL], result: STRING },
+    "text.decodeLegacyOptions": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: STRING },
     "text.decodeLegacy": { argTypes: [BYTES_U8, F64], result: STRING },
+    "text.decoderEncoding": { argTypes: [DYN], result: F64 },
     "fs.mkdirRecursiveSync": { argTypes: [STRING], result: VOID },
     "fs.rmOptsSync": { argTypes: [STRING, BOOL, BOOL], result: VOID },
     "fs.rmRetrySync": { argTypes: [STRING, BOOL, BOOL, F64, F64], result: VOID },
@@ -1338,6 +1502,7 @@ export const LIB_FN_SIGS = {
     // Arg 0 is a packed f64[] OR a bytes value (the spread-typed-array
     // form) — checked in the libCall case.
     "string.fromCharCode": { argTypes: [null], result: STRING },
+    "string.fromCodePoint": { argTypes: [null], result: STRING },
     "string.lastIndexOf": { argTypes: [STRING, STRING], result: F64 },
     "string.lastIndexOfFrom": { argTypes: [STRING, STRING, F64], result: F64 },
     "string.raw": { argTypes: [arrayOf(STRING), arrayOf(STRING)], result: STRING },
@@ -1386,6 +1551,30 @@ export function validateModule(mod) {
     }
     const retainedFfiCallbacks = new Map();
     for (const entry of mod.ffiImports ?? []) {
+        if (entry.callbackOperation !== undefined) {
+            const fail = (detail) => { errors.push({ message: `FFI callback operation "${entry.name}" ${detail}`, loc: moduleLoc }); };
+            if (!entry.library || entry.library.includes("\0"))
+                fail("requires a library name");
+            if (entry.callbackOperation === "register") {
+                const param = entry.params[0];
+                if (entry.params.length !== 1 || !param || !isFfiCallbackParam(param) ||
+                    param.callback.id !== "callback" || param.callback.lifetime !== "retained" || param.callback.invoke !== "script-thread" ||
+                    param.callback.params.some(p => typeof p !== "string" || ["cstring", "string", "bytes"].includes(p)) ||
+                    entry.returns !== "pointer" || entry.callbackTarget !== undefined)
+                    fail("has an invalid registration ABI");
+            }
+            else if (entry.callbackOperation === "release") {
+                const target = entry.callbackTarget ? ffiByName.get(entry.callbackTarget) : undefined;
+                if (entry.params.length !== 0 || entry.returns !== "void" || target?.callbackOperation !== "register" ||
+                    target.library !== entry.library)
+                    fail("has an invalid release target or ABI");
+            }
+            else
+                fail("has an invalid operation");
+        }
+        else if (entry.callbackTarget !== undefined) {
+            errors.push({ message: `FFI binding "${entry.name}" has a callback target without a release operation`, loc: moduleLoc });
+        }
         const ids = new Set();
         for (const param of entry.params) {
             if (!isFfiCallbackParam(param))
@@ -1398,6 +1587,9 @@ export function validateModule(mod) {
                 errors.push({ message: `FFI callback "${entry.name}:${param.callback.id}" has invalid invoke mode`, loc: moduleLoc });
             }
             if (param.callback.invoke === "foreign") {
+                if (param.callback.params.some((p) => p === "i64" || p === "u64" || p === "pointer")) {
+                    errors.push({ message: `FFI foreign callback "${entry.name}:${param.callback.id}" has unsupported 64-bit or pointer arguments`, loc: moduleLoc });
+                }
                 if (param.callback.lifetime !== "retained") {
                     errors.push({ message: `FFI foreign callback "${entry.name}:${param.callback.id}" is not retained`, loc: moduleLoc });
                 }
@@ -1535,6 +1727,50 @@ export function validateModule(mod) {
             errors.push({ message: `duplicate class "${cls.name}"`, loc: cls.loc });
         }
         classesByName.set(cls.name, cls);
+        if (cls.localCaptures !== undefined && (cls.runtime || cls.genericOf !== undefined)) {
+            errors.push({ message: `class ${cls.name}: local class cannot use a runtime or generic family layout`, loc: cls.loc });
+        }
+        if (cls.localCaptures !== undefined) {
+            const environment = cls.fields.find((field) => field.name === `%classEnvironment:${cls.name}`);
+            if (environment?.type.kind !== "classval" || environment.type.className !== cls.name) {
+                errors.push({ message: `class ${cls.name}: local class requires its constructor environment field`, loc: cls.loc });
+            }
+        }
+        if (cls.localBaseCapture !== undefined) {
+            const base = cls.localCaptures?.[cls.localBaseCapture];
+            if (!Number.isInteger(cls.localBaseCapture) || base?.type.kind !== "classval" || base.type.className !== cls.base) {
+                errors.push({ message: `class ${cls.name}: invalid local base capture`, loc: cls.loc });
+            }
+        }
+        if (cls.baseValueGlobal !== undefined) {
+            const global = mod.globals?.find((global) => global.id === cls.baseValueGlobal);
+            if (cls.localBaseCapture !== undefined || !cls.base || global?.type.kind !== "classval" || global.type.className !== cls.base) {
+                errors.push({ message: `class ${cls.name}: invalid computed base global`, loc: cls.loc });
+            }
+        }
+        if (cls.jsLength !== undefined && (!Number.isSafeInteger(cls.jsLength) || cls.jsLength < 0)) {
+            errors.push({ message: `class ${cls.name}: invalid constructor length`, loc: cls.loc });
+        }
+        if (cls.prototypeDataHelper !== undefined) {
+            const helper = functionsByName.get(cls.prototypeDataHelper);
+            if (!helper || helper.params.length !== 0 || helper.returnType.kind !== "dyn" || helper.captures !== undefined || helper.classCaptures !== undefined) {
+                errors.push({ message: `class ${cls.name}: prototype data helper must be a noncapturing () => dyn function`, loc: cls.loc });
+            }
+        }
+        if (cls.instancePrototypeHelper !== undefined) {
+            const helper = functionsByName.get(cls.instancePrototypeHelper);
+            const receiver = helper?.params[0]?.type;
+            if (!helper || helper.params.length !== 1 || receiver?.kind !== "object" || receiver.className !== cls.name ||
+                helper.returnType.kind !== "dyn" || helper.captures !== undefined || helper.classCaptures !== undefined) {
+                errors.push({ message: `class ${cls.name}: instance prototype helper must be a noncapturing (instance) => dyn function`, loc: cls.loc });
+            }
+        }
+        for (const symbol of cls.symbolFields ?? []) {
+            const global = mod.globals?.find((global) => global.id === symbol.globalId);
+            if (global?.type.kind !== "symbol" || !cls.fields.some((field) => field.name === symbol.field)) {
+                errors.push({ message: `class ${cls.name}: invalid symbol field metadata`, loc: cls.loc });
+            }
+        }
         const seen = new Set();
         for (const f of cls.fields) {
             if (seen.has(f.name)) {
@@ -1577,6 +1813,9 @@ export function validateModule(mod) {
             errors.push({ message: `class ${cls.name}: undeclared base "${cls.base}"`, loc: cls.loc });
             continue;
         }
+        if (base.localCaptures !== undefined && cls.localBaseCapture === undefined && cls.baseValueGlobal === undefined) {
+            errors.push({ message: `class ${cls.name}: local base requires a captured constructor`, loc: cls.loc });
+        }
         const seen = new Set([cls.name]);
         for (let c = base; c; c = c.base !== undefined ? classesByName.get(c.base) : undefined) {
             if (seen.has(c.name)) {
@@ -1651,9 +1890,16 @@ export function validateModule(mod) {
         // field count) — anything else has no honest index/JSON story.
         if (rec.tuple) {
             const names = new Set(rec.fields.map((f) => f.name));
+            let positionsComplete = true;
+            for (let i = 0; i < rec.fields.length; i++) {
+                if (!names.has(String(i))) {
+                    positionsComplete = false;
+                    break;
+                }
+            }
             if (rec.fields.length === 0 ||
                 names.size !== rec.fields.length ||
-                [...Array(rec.fields.length).keys()].some((i) => !names.has(String(i)))) {
+                !positionsComplete) {
                 errors.push({ message: `record ${rec.id}: tuple fields are not "0".."${rec.fields.length - 1}"`, loc: noLoc });
             }
             if (rec.indexValue) {
@@ -1675,31 +1921,64 @@ export function validateModule(mod) {
             errors.push({ message: `duplicate union "${u.id}"`, loc: noLoc });
         }
         unionsById.set(u.id, u);
+    }
+    for (const u of mod.unions ?? []) {
         if (u.arms.length < 2) {
             errors.push({ message: `union ${u.id}: fewer than 2 arms`, loc: noLoc });
         }
+        if (u.discriminant) {
+            const { field, cases } = u.discriminant;
+            const tags = new Set();
+            const values = new Set();
+            for (const candidate of cases) {
+                const arm = u.arms[candidate.tag];
+                const record = arm?.kind === "record" ? recordsById.get(arm.shapeId) : undefined;
+                const member = record?.fields.find((entry) => entry.name === field);
+                if (!Number.isInteger(candidate.tag) || candidate.tag < 0 || !member || tags.has(candidate.tag)) {
+                    errors.push({ message: `union ${u.id}: invalid discriminant tag ${candidate.tag}`, loc: noLoc });
+                }
+                tags.add(candidate.tag);
+                if (candidate.values.length === 0) {
+                    errors.push({ message: `union ${u.id}: empty discriminant values for tag ${candidate.tag}`, loc: noLoc });
+                }
+                for (const value of candidate.values) {
+                    if (value === undefined) {
+                        errors.push({ message: `union ${u.id}: undefined discriminant value`, loc: noLoc });
+                        continue;
+                    }
+                    const fieldTypes = member?.type.kind === "union"
+                        ? unionsById.get(member.type.unionId)?.arms ?? [] : member ? [member.type] : [];
+                    const valid = fieldTypes.some((type) => typeof value === "string" ? type.kind === "string"
+                        : typeof value === "boolean" ? type.kind === "bool"
+                            : typeof value === "number" && Number.isFinite(value) && type.kind === "f64");
+                    const key = typeof value + ":" + String(value);
+                    if (!valid || values.has(key)) {
+                        errors.push({ message: `union ${u.id}: invalid or repeated discriminant value ${key}`, loc: noLoc });
+                    }
+                    values.add(key);
+                }
+            }
+            for (let tag = 0; tag < u.arms.length; tag++) {
+                if (u.arms[tag].kind === "record" && !tags.has(tag)) {
+                    errors.push({ message: `union ${u.id}: missing discriminant for record arm ${tag}`, loc: noLoc });
+                }
+            }
+        }
         u.arms.forEach((arm, i) => {
             // The unit kinds (undefinedT/nullT) are valid arms — union membership
-            // is the ONLY place they may appear; void/union/map/dyn/jsval/date
-            // stay out (maps and scalar Date values have no supported union
-            // representation/discriminant to narrow on). Func/set arm
-            // sibling rules live in unionFuncSetArmsOk (shared with the frontend's
-            // union builders): a func arm allows unit and FUNC siblings (the
-            // nullable-callback shape, and the primitive-constructor tables where
-            // closure pointer identity per tag is the narrowing); a set arm is
-            // valid exactly when every other arm is a unit (the defaulted-Set-
-            // param ABI); func/set-beside-data stays out.
+            // is the ONLY place they may appear. Containers are valid beside
+            // unit arms: tag tests distinguish absence while the reference
+            // payload preserves identity. The shared rule refuses data siblings.
             if (arm.kind === "void" ||
                 arm.kind === "union" ||
-                arm.kind === "map" ||
                 arm.kind === "dyn" ||
                 arm.kind === "jsval" ||
                 arm.kind === "date" ||
                 arm.kind === "generator") {
                 errors.push({ message: `union ${u.id}: arm ${i} is ${arm.kind}`, loc: noLoc });
             }
-            if ((arm.kind === "func" || arm.kind === "set") &&
-                !unionFuncSetArmsOk(u.arms)) {
+            if ((arm.kind === "map" || arm.kind === "set" || arm.kind === "promise") &&
+                !unionContainerArmsOk(u.arms)) {
                 errors.push({ message: `union ${u.id}: ${arm.kind} arm ${i} beside non-unit arms`, loc: noLoc });
             }
             if (arm.kind === "record" && !recordsById.has(arm.shapeId)) {
@@ -1791,6 +2070,9 @@ export function validateModule(mod) {
         }
     };
     for (const g of mod.globals ?? []) {
+        if (g.tdz && g.type.kind !== "record" && g.type.kind !== "func" && g.type.kind !== "dyn") {
+            errors.push({ message: `TDZ global "${g.name}" must have record, function, or checked-value storage`, loc: noLoc });
+        }
         if (isUnitType(g.type)) {
             errors.push({ message: `global "${g.name}" has bare unit type ${g.type.kind}`, loc: noLoc });
         }
@@ -1890,15 +2172,16 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     // Unit kinds live only inside unions: a bare-unit local, param, or
     // return type is frontend breakage (mapType never produces them).
     for (const l of fn.locals) {
+        if (l.tdz && !l.boxed)
+            err(`TDZ local "${l.name}" must be boxed`, fn.loc);
         if (isUnitType(l.type))
             err(`local "${l.name}" has bare unit type ${l.type.kind}`, fn.loc);
     }
     if (isUnitType(fn.returnType)) {
         err(`return type is bare unit type ${fn.returnType.kind}`, fn.loc);
     }
-    // Caught (catch-binding) values are local-only by construction: they can
-    // never be parameters, returns, or captures (the frontend fences every
-    // escape; a caught anywhere else is frontend breakage).
+    // Exception snapshots may be captured, but are never public parameters
+    // or return values. Their payload crosses those boundaries explicitly.
     if (fn.returnType.kind === "caught")
         err("return type is caught", fn.loc);
     for (const p of fn.params) {
@@ -1908,14 +2191,27 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         if (p.type.kind === "caught")
             err(`param "${p.name}" is caught-typed`, fn.loc);
     }
-    for (const c of fn.captures ?? []) {
+    for (const c of [...(fn.captures ?? []), ...(fn.classCaptures ?? [])]) {
         const local = locals.get(c.localId);
         if (!local)
             err(`capture "${c.name}" has no local entry "${c.localId}"`, fn.loc);
         else if (!local.boxed)
             err(`capture local "${c.localId}" is not boxed`, fn.loc);
-        if (c.type.kind === "caught")
-            err(`capture "${c.name}" is caught-typed`, fn.loc);
+        else if (!typeEquals(local.type, c.type))
+            err(`capture local "${c.localId}" has the wrong type`, fn.loc);
+    }
+    if (fn.classCaptures !== undefined) {
+        const self = fn.params[0];
+        const cls = self?.type.kind === "object" ? classes.get(self.type.className) : undefined;
+        if (fn.captures !== undefined || cls?.localCaptures === undefined) {
+            err("class captures require a local-class instance receiver and no closure environment", fn.loc);
+        }
+        for (const capture of fn.classCaptures) {
+            const slot = cls?.localCaptures?.[capture.slot];
+            if (!Number.isInteger(capture.slot) || !slot || !typeEquals(slot.type, capture.type)) {
+                err(`class capture "${capture.name}" has an invalid slot or type`, fn.loc);
+            }
+        }
     }
     const expectType = (expr, want, what) => {
         if (!typeEquals(expr.type, want)) {
@@ -1957,12 +2253,218 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         seen.add(type.unionId);
         return unions.get(type.unionId)?.arms.some((arm) => liveDynRefEligible(arm, seen)) ?? false;
     };
+    function checkNullishOperands(e) {
+        expectType(e.right, e.type, "nullish right operand");
+        // The ISLAND form: `a ?? b` over an engine value — left, right,
+        // and result are all handles (the emitters' jsval nullish arm).
+        if (e.left.type.kind === "jsval") {
+            if (e.type.kind !== "jsval")
+                err("jsval nullish must answer jsval", e.loc);
+            return;
+        }
+        // The CHECKED-DYNAMIC form: the runtime kind decides (the
+        // emitters' scr_dyn_is_nullish arm) — left, right, and result
+        // all live in the checked-dynamic tree.
+        if (e.left.type.kind === "dyn") {
+            if (e.type.kind !== "dyn")
+                err("dyn nullish must answer dyn", e.loc);
+            return;
+        }
+        if (e.left.type.kind !== "union") {
+            err(`nullish left must be a union, got ${e.left.type.kind}`, e.loc);
+            return;
+        }
+        const def = unions.get(e.left.type.unionId);
+        if (!def) {
+            err(`nullish left references unknown union ${e.left.type.unionId}`, e.loc);
+            return;
+        }
+        if (!def.arms.some(isUnitType)) {
+            err("nullish left union has no unit arm (frontend must fence)", e.loc);
+        }
+        // Two shapes: pass-through (type === left's union) or narrowed
+        // (type === the union's SINGLE non-unit arm).
+        if (!typeEquals(e.type, e.left.type)) {
+            const rest = def.arms.filter((a) => !isUnitType(a));
+            if (rest.length !== 1 || !typeEquals(e.type, rest[0])) {
+                err("nullish type must be the left union or its single non-unit arm", e.loc);
+            }
+        }
+    }
+    function checkBranchingTree(root) {
+        // Predicates and conditional dispatch can nest in either direction.
+        // Preserve child-before-parent diagnostics with bounded native stack
+        // use, including trees that mix the three branching operators.
+        const pending = [{ expr: root, visited: false }];
+        while (pending.length !== 0) {
+            const task = pending.pop();
+            const e = task.expr;
+            if (!task.visited) {
+                if (e.kind === "logical" || e.kind === "nullish") {
+                    pending.push({ expr: e, visited: true });
+                    pending.push({ expr: e.right, visited: false });
+                    pending.push({ expr: e.left, visited: false });
+                }
+                else if (e.kind === "ternary") {
+                    pending.push({ expr: e, visited: true });
+                    pending.push({ expr: e.else_, visited: false });
+                    pending.push({ expr: e.then, visited: false });
+                    pending.push({ expr: e.cond, visited: false });
+                }
+                else {
+                    checkExpr(e);
+                }
+                continue;
+            }
+            if (e.kind === "logical") {
+                if (e.type.kind !== "f64" && e.type.kind !== "string" && e.type.kind !== "bool" &&
+                    e.type.kind !== "jsval" && e.type.kind !== "union" && e.type.kind !== "dyn") {
+                    err(`logical ${e.op} must be f64|string|bool|jsval|union|dyn, got ${e.type.kind}`, e.loc);
+                }
+                if (e.type.kind === "union")
+                    checkTruthyUnion(e.type.unionId, e.loc);
+                expectType(e.left, e.type, `logical ${e.op} left`);
+                expectType(e.right, e.type, `logical ${e.op} right`);
+            }
+            else if (e.kind === "nullish") {
+                checkNullishOperands(e);
+            }
+            else if (e.kind === "ternary") {
+                expectType(e.cond, BOOL, "ternary condition");
+                expectType(e.then, e.type, "ternary then-branch");
+                expectType(e.else_, e.type, "ternary else-branch");
+                if (e.type.kind === "void")
+                    err("ternary must not be void", e.loc);
+            }
+        }
+    }
+    // Keep expression families in separate functions so native bootstrap builds
+    // do not feed LLVM a single control-flow graph containing every IR check.
     function checkExpr(e) {
+        switch (e.kind) {
+            case "numLit":
+            case "strLit":
+            case "moduleNsRef":
+            case "boolLit":
+            case "unitLit":
+            case "varRef":
+            case "bin":
+            case "unary":
+            case "incDec":
+            case "fieldIncDec":
+            case "assignExpr":
+            case "seqExpr":
+            case "dynDestrCheck":
+            case "dynIterN":
+            case "toBool":
+            case "logical":
+            case "nullish":
+            case "ternary":
+            case "unionEq":
+            case "unionFuncEq":
+                return checkScalarExpr(e);
+            case "strConcat":
+            case "strEq":
+            case "strCmp":
+            case "optChain":
+            case "chainRecv":
+            case "orDefault":
+            case "toString":
+            case "strIntrinsic":
+            case "regexLit":
+            case "templateStrings":
+            case "regexIntrinsic":
+                return checkStringExpr(e);
+            case "arrayLit":
+            case "arrayNewLen":
+            case "arrayGet":
+            case "arrayHas":
+            case "arrayState":
+            case "bytesNew":
+            case "bytesIntrinsic":
+            case "arrIntrinsic":
+                return checkArrayExpr(e);
+            case "mapNew":
+            case "mapIntrinsic":
+            case "setNew":
+            case "setIntrinsic":
+                return checkCollectionExpr(e);
+            case "call":
+            case "ffiCall":
+            case "closure":
+            case "callValue":
+                return checkCallExpr(e);
+            case "selfRef":
+            case "new":
+            case "fieldGet":
+            case "promiseVoidWiden":
+            case "upcast":
+            case "downcast":
+            case "classRef":
+            case "newValue":
+            case "instanceOfValue":
+            case "instanceOf":
+            case "virtualCall":
+                return checkClassExpr(e);
+            case "recordLit":
+            case "recordClone":
+            case "recordGet":
+            case "recordKeyGet":
+            case "recordOvfHas":
+            case "recordOvfKeys":
+                return checkRecordExpr(e);
+            case "dynFrom":
+            case "dynFromJsval":
+            case "dynCall":
+            case "dynInvoke":
+            case "dynObjLit":
+            case "dynArrLit":
+            case "unionWrap":
+            case "dynTest":
+            case "dynKeyGet":
+            case "dynHasKey":
+            case "dynScalarEq":
+            case "caughtTest":
+            case "caughtCheck":
+            case "caughtToDyn":
+            case "caughtNarrow":
+                return checkDynamicExpr(e);
+            case "unionNarrow":
+            case "unionDisc":
+            case "unionKeyGet":
+            case "unionIsTag":
+                return checkUnionExpr(e);
+            case "intrinsic":
+                return checkIntrinsicExpr(e);
+            case "libCall":
+                return checkLibCall(e);
+            case "jsonStringify":
+            case "dynCheck":
+                return checkConversionExpr(e);
+            case "awaitExpr":
+            case "yieldExpr":
+            case "genResume":
+            case "awaitUnionExpr":
+            case "newPromise":
+            case "promiseWithResolvers":
+                return checkAsyncExpr(e);
+            case "jsMarshal":
+            case "jsOp":
+            case "jsExit":
+            case "jsBridgePromise":
+                return checkIslandExpr(e);
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkScalarExpr(e) {
         switch (e.kind) {
             case "numLit":
                 // ±Infinity and NaN are real literals (the globals
-                // `Infinity`/`NaN`, Number constants) — both backends spell them
-                // (INFINITY/NAN macros in C, bit-encoded f64 in LLVM).
+                // `Infinity`/`NaN`, Number constants) — the backend spells them
+                // (bit-encoded f64 in LLVM).
                 // procStream is the ONE non-f64 numLit: process.stdout/stderr as
                 // first-class values mint the stream's fd (1/2) as the scalar —
                 // the prefixStream idiom.
@@ -2026,6 +2528,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     (e.left.type.kind === "array" ||
                         e.left.type.kind === "map" ||
                         e.left.type.kind === "set" ||
+                        e.left.type.kind === "regex" ||
+                        e.left.type.kind === "url" ||
                         e.left.type.kind === "object" ||
                         e.left.type.kind === "record" ||
                         // Symbol identity IS pointer identity (the frontend's rule).
@@ -2129,12 +2633,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // Statements in an expression cannot jump out of the expression,
                 // but a local state branch is valid: optional array stores must
                 // choose ARRAY_VALUE versus ARRAY_UNDEFINED before the final result
-                // is evaluated. Nested blocks/ifs are checked recursively below.
-                const allowed = new Set(["varDecl", "assign", "exprStmt", "fieldSet", "recordSet", "recordKeySet", "arraySet", "arraySetLength", "arraySetUndefined", "arrayDelete", "bytesSet", "block", "if"]);
+                // is evaluated. Delegation also needs a local loop. Nested control
+                // flow is checked recursively; jumps still cannot leave the region.
+                const allowed = new Set(["varDecl", "assign", "exprStmt", "fieldSet", "recordSet", "recordKeySet", "arraySet", "arraySetLength", "arraySetUndefined", "arrayDelete", "bytesSet", "block", "if", "while"]);
+                if (e.generatorDelegate) {
+                    if (!fn.generator || fn.async)
+                        err("delegation sequence outside a synchronous generator", e.loc);
+                    allowed.add("return");
+                    allowed.add("throw");
+                    allowed.add("runtimeFence");
+                }
                 const flat = (ss) => {
                     for (const s of ss) {
                         if (!allowed.has(s.kind)) {
-                            err(`seqExpr statement kind "${s.kind}" is not straight-line`, s.loc);
+                            err(`seqExpr statement kind "${s.kind}" can leave the expression`, s.loc);
                             continue;
                         }
                         if (s.kind === "block") {
@@ -2148,6 +2660,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                             checkExpr(s.cond);
                             continue;
                         }
+                        if (s.kind === "while") {
+                            expectType(s.cond, BOOL, "seqExpr while condition");
+                            checkExpr(s.cond);
+                            flat(s.body);
+                            continue;
+                        }
                         checkStmt(s);
                     }
                 };
@@ -2190,16 +2708,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err("toBool must be bool", e.loc);
                 break;
             case "logical":
-                checkExpr(e.left);
-                checkExpr(e.right);
-                if (e.type.kind !== "f64" && e.type.kind !== "string" && e.type.kind !== "bool" &&
-                    e.type.kind !== "jsval" && e.type.kind !== "union" && e.type.kind !== "dyn") {
-                    err(`logical ${e.op} must be f64|string|bool|jsval|union|dyn, got ${e.type.kind}`, e.loc);
-                }
-                if (e.type.kind === "union")
-                    checkTruthyUnion(e.type.unionId, e.loc);
-                expectType(e.left, e.type, `logical ${e.op} left`);
-                expectType(e.right, e.type, `logical ${e.op} right`);
+            case "nullish":
+            case "ternary":
+                checkBranchingTree(e);
                 break;
             case "unionEq": {
                 checkExpr(e.left);
@@ -2233,6 +2744,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err("unionFuncEq must be bool", e.loc);
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkStringExpr(e) {
+        switch (e.kind) {
             case "strConcat":
                 checkExpr(e.left);
                 checkExpr(e.right);
@@ -2250,16 +2769,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 if (e.type.kind !== "bool")
                     err(`${e.kind} must be bool`, e.loc);
                 break;
-            case "ternary":
-                checkExpr(e.cond);
-                checkExpr(e.then);
-                checkExpr(e.else_);
-                expectType(e.cond, BOOL, "ternary condition");
-                expectType(e.then, e.type, "ternary then-branch");
-                expectType(e.else_, e.type, "ternary else-branch");
-                if (e.type.kind === "void")
-                    err("ternary must not be void", e.loc);
-                break;
             case "optChain": {
                 checkExpr(e.receiver);
                 // An island-handle chain (`x?.y` on 'any'): the nullish test is a
@@ -2312,13 +2821,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     break;
                 }
                 const rest = def.arms.filter((a) => !isUnitType(a));
-                if (rest.length !== 1 || rest.length === def.arms.length) {
-                    err("optChain receiver must have unit arms and exactly one non-unit arm", e.loc);
+                if (rest.length === 0 || rest.length === def.arms.length) {
+                    err("optChain receiver must have unit arms and at least one non-unit arm", e.loc);
                     break;
                 }
                 if (activeChains.has(e.id))
                     err(`optChain id "${e.id}" shadows an active chain`, e.loc);
-                activeChains.set(e.id, rest[0]);
+                activeChains.set(e.id, rest.length === 1 ? rest[0] : e.receiver.type);
                 checkExpr(e.body);
                 activeChains.delete(e.id);
                 if (e.type.kind === "void") {
@@ -2347,47 +2856,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 expectType(e, bound, "chainRecv");
                 break;
             }
-            case "nullish": {
-                checkExpr(e.left);
-                checkExpr(e.right);
-                expectType(e.right, e.type, "nullish right operand");
-                // The ISLAND form: `a ?? b` over an engine value — left, right,
-                // and result are all handles (the emitters' jsval nullish arm).
-                if (e.left.type.kind === "jsval") {
-                    if (e.type.kind !== "jsval")
-                        err("jsval nullish must answer jsval", e.loc);
-                    break;
-                }
-                // The CHECKED-DYNAMIC form: the runtime kind decides (the
-                // emitters' scr_dyn_is_nullish arm) — left, right, and result
-                // all live in the checked-dynamic tree.
-                if (e.left.type.kind === "dyn") {
-                    if (e.type.kind !== "dyn")
-                        err("dyn nullish must answer dyn", e.loc);
-                    break;
-                }
-                if (e.left.type.kind !== "union") {
-                    err(`nullish left must be a union, got ${e.left.type.kind}`, e.loc);
-                    break;
-                }
-                const def = unions.get(e.left.type.unionId);
-                if (!def) {
-                    err(`nullish left references unknown union ${e.left.type.unionId}`, e.loc);
-                    break;
-                }
-                if (!def.arms.some(isUnitType)) {
-                    err("nullish left union has no unit arm (frontend must fence)", e.loc);
-                }
-                // Two shapes: pass-through (type === left's union) or narrowed
-                // (type === the union's SINGLE non-unit arm).
-                if (!typeEquals(e.type, e.left.type)) {
-                    const rest = def.arms.filter((a) => !isUnitType(a));
-                    if (rest.length !== 1 || !typeEquals(e.type, rest[0])) {
-                        err("nullish type must be the left union or its single non-unit arm", e.loc);
-                    }
-                }
-                break;
-            }
             case "orDefault": {
                 checkExpr(e.left);
                 checkExpr(e.right);
@@ -2434,7 +2902,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`toString of unknown union ${e.operand.type.unionId}`, e.loc);
                     }
                     else if (!def.arms.every((a) => a.kind === "undefinedT" || a.kind === "nullT" ||
-                        a.kind === "string" || a.kind === "f64" || a.kind === "bool" ||
+                        a.kind === "string" || a.kind === "f64" || a.kind === "bigint" || a.kind === "bool" ||
                         (a.kind === "bytes" && a.elem === "u8"))) {
                         err("toString union operand has a non-stringable arm (frontend must fence)", e.loc);
                     }
@@ -2504,7 +2972,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     if (want)
                         expectType(a, want, `regexIntrinsic ${e.method} arg ${i}`);
                 });
-                if (e.method === "match") {
+                if (e.method === "match" || e.method === "exec") {
                     // The `string[] | null` union (program-dependent id) — checked
                     // by arms, like the libCall case checks process.envGet.
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
@@ -2521,6 +2989,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkArrayExpr(e) {
+        switch (e.kind) {
             case "arrayLit": {
                 if (e.type.kind !== "array") {
                     err(`arrayLit must be array-typed, got ${e.type.kind}`, e.loc);
@@ -2602,21 +3078,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 if (e.source) {
                     checkExpr(e.source);
                     const sk = e.source.type;
-                    if (sk.kind === "bytes") {
-                        // Same-elem copies only (cross-kind construction is fenced).
-                        if (!typeEquals(sk, e.type)) {
-                            err(`bytesNew copy source elem mismatch`, e.loc);
-                        }
-                    }
-                    else if (sk.kind === "array") {
+                    if (sk.kind === "array") {
                         if (sk.elem.kind !== "f64") {
                             err(`bytesNew array source must hold f64, got ${sk.elem.kind}`, e.loc);
                         }
                     }
-                    else if (sk.kind !== "f64") {
+                    else if (sk.kind !== "f64" && sk.kind !== "bytes" && sk.kind !== "dyn") {
                         err(`bytesNew source of kind ${sk.kind}`, e.loc);
                     }
                 }
+                if (e.from && e.source?.type.kind !== "dyn")
+                    err("bytesNew from requires a dyn source", e.loc);
                 break;
             }
             case "bytesIntrinsic": {
@@ -2652,6 +3124,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err(`bytesIntrinsic ${e.method} args[1] must be a strLit encoding`, e.loc);
                 }
                 const EXTRA_SIGS = {
+                    buffer: { argTypes: [], minArgs: 0, result: DYN },
+                    setFromDyn: { argTypes: [DYN, F64], minArgs: 1, result: VOID },
+                    copyWithin: { argTypes: [F64, F64, F64], minArgs: 3, result: bytesOf(recv.elem) },
                     equals: { argTypes: [BYTES_U8], minArgs: 1, result: BOOL },
                     compareBuf: { argTypes: [BYTES_U8, F64, F64, F64, F64], minArgs: 1, result: F64 },
                     // [needle, align, byteOffset?] — an OMITTED byteOffset is Node's
@@ -2691,7 +3166,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                                         : e.method === "toArray"
                                             ? { argTypes: [], minArgs: 0, result: arrayOf(F64) }
                                             : e.method === "setFrom"
-                                                ? { argTypes: [bytesOf(recv.elem), F64], minArgs: 1, result: VOID }
+                                                ? { argTypes: [e.args[0]?.type.kind === "bytes" ? e.args[0].type : bytesOf(recv.elem), F64], minArgs: 1, result: VOID }
                                                 : e.method === "toString" || e.method === "toStringVar"
                                                     ? { argTypes: [STRING, F64, F64], minArgs: 1, result: STRING }
                                                     : e.method === "readNum"
@@ -2803,7 +3278,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     // misjudge JS ===; the frontend fences these.
                     err(`arrIntrinsic ${e.method} on union elements (frontend must reject)`, e.loc);
                 }
-                if (e.method === "shift" || e.method === "pop") {
+                if ((e.method === "shift" || e.method === "pop") && !(elem.kind === "dyn" && e.type.kind === "dyn")) {
                     const rdef = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     if (!rdef ||
                         !rdef.arms.some((arm) => arm.kind === "undefinedT") ||
@@ -2829,12 +3304,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkCollectionExpr(e) {
+        switch (e.kind) {
             case "mapNew": {
                 if (e.type.kind !== "map") {
                     err(`mapNew must be map-typed, got ${e.type.kind}`, e.loc);
                     break;
                 }
-                if (!isSupportedMapKey(e.type.key)) {
+                if (!isSupportedMapKey(e.type.key, e.type.key.kind === "union" ? unions.get(e.type.key.unionId)?.arms : undefined)) {
                     err(`mapNew key kind ${e.type.key.kind} (frontend must fence)`, e.loc);
                 }
                 if (!isSupportedMapValue(e.type.value)) {
@@ -2868,6 +3351,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     checkExpr(e.args[0]);
                     expectType(e.args[0], key, "mapIntrinsic get key");
+                    if (value.kind === "dyn") {
+                        expectType(e, DYN, "mapIntrinsic get result");
+                        break;
+                    }
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     const rest = def ? def.arms.filter((a) => a.kind !== "undefinedT") : [];
                     // When V is itself a union its own undefined arm (if any) folds
@@ -2917,7 +3404,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err(`setNew must be set-typed, got ${e.type.kind}`, e.loc);
                     break;
                 }
-                if (!isSupportedSetElem(e.type.elem)) {
+                if (!isSupportedSetElem(e.type.elem, e.type.elem.kind === "union" ? unions.get(e.type.elem.unionId)?.arms : undefined)) {
                     err(`setNew element kind ${e.type.elem.kind} (frontend must fence)`, e.loc);
                 }
                 // The seed is one T[]-typed expression (T = the element type).
@@ -2961,6 +3448,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkCallExpr(e) {
+        switch (e.kind) {
             case "call": {
                 for (const a of e.args)
                     checkExpr(a);
@@ -3060,6 +3555,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             case "callValue": {
                 checkExpr(e.callee);
+                if (e.receiver !== undefined) {
+                    checkExpr(e.receiver);
+                    expectType(e.receiver, DYN, "callValue receiver");
+                }
                 for (const a of e.args)
                     checkExpr(a);
                 if (e.callee.type.kind !== "func") {
@@ -3080,6 +3579,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkClassExpr(e) {
+        switch (e.kind) {
             case "selfRef":
                 if (fn.captures === undefined) {
                     err("selfRef outside a lifted function", e.loc);
@@ -3096,6 +3603,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     break;
                 }
                 const ctor = functions.get(`%${e.className}.constructor`);
+                if (cls.localCaptures !== undefined)
+                    err(`new ${e.className}: local class requires a class value`, e.loc);
                 if (!ctor) {
                     err(`new ${e.className}: missing constructor function`, e.loc);
                     break;
@@ -3205,6 +3714,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 if (!typeEquals(e.type, { kind: "classval", className: e.className })) {
                     err(`classRef to "${e.className}" must have that classval type`, e.loc);
                 }
+                if ((e.captures === undefined) !== (cls.localCaptures === undefined) ||
+                    (e.captures?.length ?? 0) !== (cls.localCaptures?.length ?? 0)) {
+                    err(`classRef to "${e.className}" must supply its class captures`, e.loc);
+                }
+                (e.captures ?? []).forEach((id, index) => {
+                    const local = locals.get(id);
+                    const wanted = cls.localCaptures?.[index];
+                    if (!local?.boxed || (wanted && !typeEquals(local.type, wanted.type))) {
+                        err(`classRef capture "${id}" must name a box with the declared type`, e.loc);
+                    }
+                });
                 break;
             }
             case "newValue": {
@@ -3248,6 +3768,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // Both sides must be hierarchy members: the operand needs a vt
                 // word to read; a standalone target class has one possible value
                 // and the frontend folds it statically.
+                if (classes.get(e.classValue.type.className)?.localCaptures !== undefined &&
+                    e.value.type.kind === "object" && classes.get(e.value.type.className)?.localCaptures !== undefined)
+                    break;
                 if (!hierarchy.has(e.classValue.type.className)) {
                     err(`instanceOfValue against standalone class "${e.classValue.type.className}"`, e.loc);
                 }
@@ -3325,6 +3848,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkRecordExpr(e) {
+        switch (e.kind) {
             case "recordLit": {
                 if (e.type.kind !== "record") {
                     err(`recordLit must be record-typed, got ${e.type.kind}`, e.loc);
@@ -3444,8 +3975,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // literal key naming no declared field) skip the declared check
                 // and require the overflow to exist.
                 const surfaces = (t) => typeEquals(t, e.type) ||
-                    (e.type.kind === "union" &&
-                        (unions.get(e.type.unionId)?.arms.some((a) => typeEquals(a, t)) ?? false)) ||
+                    (e.type.kind === "union" && (() => {
+                        const result = unions.get(e.type.unionId);
+                        const source = t.kind === "union" ? unions.get(t.unionId) : undefined;
+                        return !!result && (result.arms.some((a) => typeEquals(a, t)) ||
+                            (!!source && unionWideningTags(source.arms, result.arms) !== null));
+                    })()) ||
                     e.type.kind === "dyn";
                 if (e.overflowOnly && !shape.indexValue) {
                     err(`recordKeyGet on ${e.shapeId}: overflowOnly read of a shape without an index signature`, e.loc);
@@ -3461,6 +3996,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            case "recordOvfHas": {
+                checkExpr(e.obj);
+                checkExpr(e.key);
+                const shape = records.get(e.shapeId);
+                if (!shape)
+                    err(`recordOvfHas on undeclared shape "${e.shapeId}"`, e.loc);
+                else if (!shape.indexValue || shape.tuple)
+                    err(`recordOvfHas on ${e.shapeId}: requires an index-signature record`, e.loc);
+                expectType(e.obj, { kind: "record", shapeId: e.shapeId }, "recordOvfHas receiver");
+                expectType(e.key, STRING, "recordOvfHas key");
+                if (e.type.kind !== "bool")
+                    err("recordOvfHas must be bool", e.loc);
+                break;
+            }
             case "recordOvfKeys": {
                 checkExpr(e.obj);
                 const shape = records.get(e.shapeId);
@@ -3476,6 +4025,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkDynamicExpr(e) {
+        switch (e.kind) {
             case "dynFrom": {
                 if (e.type.kind !== "dyn")
                     err(`dynFrom must be dyn-typed, got ${e.type.kind}`, e.loc);
@@ -3517,6 +4074,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             case "dynCall": {
                 checkExpr(e.callee);
+                if (e.receiver !== undefined) {
+                    checkExpr(e.receiver);
+                    expectType(e.receiver, DYN, "dynCall receiver");
+                }
                 expectType(e.callee, DYN, "dynCall callee");
                 if (e.type.kind !== "dyn")
                     err(`dynCall must be dyn-typed, got ${e.type.kind}`, e.loc);
@@ -3559,8 +4120,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err(`dynObjLit must be dyn-typed, got ${e.type.kind}`, e.loc);
                 for (const f of e.fields ?? []) {
                     checkExpr(f.key);
-                    if (f.key.type.kind !== "string")
-                        err(`dynObjLit key of kind ${f.key.type.kind} (must be string)`, e.loc);
+                    if (f.key.type.kind !== "string" && f.key.type.kind !== "dyn")
+                        err(`dynObjLit key of kind ${f.key.type.kind} (must be string or dyn)`, e.loc);
                     checkExpr(f.value);
                     if (f.value.type.kind !== "dyn")
                         err(`dynObjLit field value of kind ${f.value.type.kind} (must be dyn)`, e.loc);
@@ -3622,14 +4183,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 expectType(e.value, { kind: "dyn" }, "dynTest operand");
                 if (e.type.kind !== "bool")
                     err("dynTest must be bool", e.loc);
+                if (e.bytesElem !== undefined && (e.test !== "bytes" || !Object.hasOwn(BYTES_ELEMENT_NAME, e.bytesElem))) {
+                    err("dynTest bytesElem requires a valid bytes test", e.loc);
+                }
                 break;
             }
             case "dynKeyGet": {
                 checkExpr(e.value);
                 checkExpr(e.key);
                 expectType(e.value, { kind: "dyn" }, "dynKeyGet operand");
-                if (e.key.type.kind !== "string")
-                    err(`dynKeyGet key is ${e.key.type.kind}, not string`, e.loc);
+                if (e.key.type.kind !== "string" && e.key.type.kind !== "dyn")
+                    err(`dynKeyGet key is ${e.key.type.kind}, not string or dyn`, e.loc);
                 if (e.type.kind !== "dyn")
                     err("dynKeyGet must be dyn", e.loc);
                 break;
@@ -3704,6 +4268,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkUnionExpr(e) {
+        switch (e.kind) {
             case "unionNarrow": {
                 checkExpr(e.value);
                 const def = unions.get(e.unionId);
@@ -3777,7 +4349,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // non-unit arms have no keyed read at all. Number keys read ARRAY
                 // arms; string keys read RECORD arms.
                 const resultUnion = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                const surfaces = (t) => typeEquals(t, e.type) || !!resultUnion?.arms.some((a) => typeEquals(a, t));
+                const surfaces = (t) => typeEquals(t, e.type) || !!resultUnion?.arms.some((a) => typeEquals(a, t)) ||
+                    (t.kind === "union" && !!resultUnion && (() => {
+                        const source = unions.get(t.unionId);
+                        return !!source && unionWideningTags(source.arms, resultUnion.arms) !== null;
+                    })());
                 def.arms.forEach((arm, i) => {
                     if (arm.kind === "undefinedT" || arm.kind === "nullT") {
                         if (!resultUnion?.arms.some((a) => a.kind === "undefinedT")) {
@@ -3832,1296 +4408,1351 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     err("unionIsTag must be bool", e.loc);
                 break;
             }
-            case "intrinsic":
-                if (e.name === "module.await") {
-                    if (e.args.length !== 1)
-                        err("module.await takes exactly one argument", e.loc);
-                    for (const a of e.args) {
-                        checkExpr(a);
-                        if (a.type.kind !== "promise" || a.type.inner.kind !== "void") {
-                            err(`${typeKey(a.type)} argument to module.await (needs promise<void>)`, a.loc);
-                        }
-                    }
-                    if (e.type.kind !== "void")
-                        err("module.await must be void", e.loc);
-                    break;
-                }
-                if (e.name === "promise.all") {
-                    // ONE argument: an array of promises whose inner type is the
-                    // result's array element (or void, collapsing to promise<void>).
-                    // The exact-inner-type rule is the frontend's fence; the coarse
-                    // shape keeps hand-written IR honest.
-                    if (e.args.length !== 1)
-                        err("promise.all takes exactly one argument", e.loc);
-                    for (const a of e.args) {
-                        checkExpr(a);
-                        if (a.type.kind !== "array" || a.type.elem.kind !== "promise") {
-                            err(`${a.type.kind} argument to promise.all (needs an array of promises)`, a.loc);
-                        }
-                    }
-                    if (e.type.kind !== "promise")
-                        err("promise.all must be promise-typed", e.loc);
-                    else if (e.type.inner.kind !== "array" && e.type.inner.kind !== "void") {
-                        err("promise.all result must be a promise of an array (or void)", e.loc);
-                    }
-                    break;
-                }
-                if (e.name === "promise.reject") {
-                    // ONE argument: the %Error-rooted reason object (the rejection
-                    // payload shares the thrown-Error representation — the
-                    // frontend's fence pins the hierarchy; the coarse object shape
-                    // keeps hand-written IR honest) or a checked-dynamic reason
-                    // (the thrown-dyn representation — identity flows to catch and
-                    // unhandledRejection observers). The result is the
-                    // context-named promise.
-                    if (e.args.length !== 1)
-                        err("promise.reject takes exactly one argument", e.loc);
-                    for (const a of e.args) {
-                        checkExpr(a);
-                        if (a.type.kind !== "object" && a.type.kind !== "dyn") {
-                            err(`${a.type.kind} argument to promise.reject (needs an Error object or a dyn reason)`, a.loc);
-                        }
-                    }
-                    if (e.type.kind !== "promise")
-                        err("promise.reject must be promise-typed", e.loc);
-                    break;
-                }
-                if (e.name === "promise.resolve") {
-                    // Zero args (Promise<void>) or one plain value of the result's
-                    // inner type — promise arguments never reach the intrinsic
-                    // (the frontend returns them as-is).
-                    if (e.args.length > 1)
-                        err("promise.resolve takes at most one argument", e.loc);
-                    for (const a of e.args) {
-                        checkExpr(a);
-                        if (a.type.kind === "promise") {
-                            err("promise argument to promise.resolve (identity belongs in the frontend)", a.loc);
-                        }
-                    }
-                    if (e.type.kind !== "promise")
-                        err("promise.resolve must be promise-typed", e.loc);
-                    else if (e.args.length === 0 && e.type.inner.kind !== "void") {
-                        err("zero-argument promise.resolve must be promise<void>", e.loc);
-                    }
-                    else if (e.args.length === 1 && !typeEquals(e.args[0].type, e.type.inner)) {
-                        err("promise.resolve argument must be the result's inner type", e.loc);
-                    }
-                    break;
-                }
-                if (e.name === "promise.race") {
-                    // Entries are promises; the result is the combined promise. The
-                    // per-entry inner-type compatibility (equal to the result inner,
-                    // one of its union arms, or a sub-union of it) is the frontend's
-                    // fence; here the coarse shape keeps hand-written IR honest.
-                    if (e.args.length === 0)
-                        err("promise.race with no entries", e.loc);
-                    for (const a of e.args) {
-                        checkExpr(a);
-                        if (a.type.kind !== "promise") {
-                            err(`${a.type.kind} entry in promise.race`, a.loc);
-                        }
-                    }
-                    if (e.type.kind !== "promise")
-                        err("promise.race must be promise-typed", e.loc);
-                    break;
-                }
-                for (const a of e.args) {
-                    checkExpr(a);
-                    // Arrays/functions/records/unions stay out of console.log (and
-                    // its stderr twin console.error) by design (the ambient signature
-                    // accepts number|string|boolean; a union of those satisfies it,
-                    // so the frontend rejects union args explicitly) — inspect
-                    // formatting is unimplemented, so the backend must never see one.
-                    if (a.type.kind !== "f64" && a.type.kind !== "string" && a.type.kind !== "bool") {
-                        err(`${a.type.kind} argument to ${e.name}`, a.loc);
-                    }
-                }
-                if (e.type.kind !== "void")
-                    err(`${e.name} must be void`, e.loc);
-                break;
-            case "libCall": {
-                const sig = LIB_FN_SIGS[e.fn];
-                if (!sig) {
-                    err(`libCall of unknown library function "${e.fn}"`, e.loc);
-                    break;
-                }
-                // emitter.emit is variadic: (recv, name) plus the event's tuple.
-                // The stream constructors (trailing option callbacks), write/end
-                // (the optional chunk/cb tail), and unpipe (the optional
-                // destination) admit a longer list the same way.
-                const variadic = e.fn === "emitter.emit" || e.fn === "emitter.emitFlex" ||
-                    e.fn === "readable.new" || e.fn === "writable.new" ||
-                    e.fn === "duplex.new" || e.fn === "transform.new" ||
-                    e.fn === "passthrough.new" ||
-                    e.fn === "readable.init" || e.fn === "writable.init" ||
-                    e.fn === "duplex.init" || e.fn === "transform.init" ||
-                    e.fn === "passthrough.init" ||
-                    e.fn === "readable.initDyn" || e.fn === "writable.initDyn" ||
-                    e.fn === "duplex.initDyn" || e.fn === "transform.initDyn" ||
-                    e.fn === "passthrough.initDyn" ||
-                    e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn" ||
-                    e.fn === "sp.pipeline" ||
-                    e.fn === "writable.write" ||
-                    e.fn === "writable.writeStr" || e.fn === "writable.writeU" ||
-                    e.fn === "writable.end" ||
-                    e.fn === "readable.unpipe";
-                if (variadic
-                    ? e.args.length < sig.argTypes.length
-                    : e.args.length !== sig.argTypes.length) {
-                    err(`libCall ${e.fn}: ${e.args.length} args, expected ${sig.argTypes.length}`, e.loc);
-                }
-                e.args.forEach((a, i) => {
-                    checkExpr(a);
-                    const want = sig.argTypes[i];
-                    if (want)
-                        expectType(a, want, `libCall ${e.fn} arg ${i}`);
-                });
-                if (e.fn === "fileHandle.read" || e.fn === "fileHandle.writeBytes" || e.fn === "fileHandle.writeStr") {
-                    const inner = e.type.kind === "promise" ? e.type.inner : undefined;
-                    const shape = inner?.kind === "record" ? records.get(inner.shapeId) : undefined;
-                    const countName = e.fn === "fileHandle.read" ? "bytesRead" : "bytesWritten";
-                    const payload = e.args[1]?.type;
-                    const count = shape?.fields.find((f) => f.name === countName);
-                    const buffer = shape?.fields.find((f) => f.name === "buffer");
-                    const ok = shape !== undefined && !shape.tuple && shape.indexValue === undefined && shape.fields.length === 2 &&
-                        count?.type.kind === "f64" && payload !== undefined && buffer !== undefined &&
-                        typeEquals(buffer.type, payload);
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return a promise of { ${countName}: number, buffer }`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "fetch.streamFrom") {
-                    const t = e.args[0]?.type;
-                    const ok = t?.kind === "string" ||
-                        (t?.kind === "bytes" && t.elem === "u8") ||
-                        (t?.kind === "array" &&
-                            canConvertToDyn(t.elem, (id) => records.get(id), (id) => unions.get(id))) ||
-                        t?.kind === "dyn";
-                    if (!ok) {
-                        err(`libCall fetch.streamFrom arg 0: expected a supported iterable, got ${t?.kind}`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "fetch.readerRead") {
-                    if (e.type.kind !== "promise" || e.type.inner.kind !== "record") {
-                        err(`libCall fetch.readerRead must return a promise of a read-result record`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "fetch.responseText" || e.fn === "fetch.responseBytes") {
-                    const valueType = e.fn === "fetch.responseText" ? STRING : BYTES_U8;
-                    const inner = e.type.kind === "promise" ? e.type.inner : null;
-                    const union = inner?.kind === "union" ? unions.get(inner.unionId) : undefined;
-                    if (inner === null ||
-                        (!typeEquals(inner, valueType) &&
-                            !union?.arms.some((arm) => typeEquals(arm, valueType)))) {
-                        err(`libCall ${e.fn} must return a promise whose value includes ${valueType.kind}`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "string.fromCharCode") {
-                    // One packed f64[] or one bytes value (the spread form).
-                    const t = e.args[0]?.type;
-                    const ok = t && ((t.kind === "array" && t.elem.kind === "f64") || t.kind === "bytes");
-                    if (!ok) {
-                        err(`libCall string.fromCharCode arg 0: expected number[] or bytes, got ${t?.kind}`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "process.envGet") {
-                    // Result is the module's interned `string | undefined` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "string" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall process.envGet must return the 'string | undefined' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "process.columns" || e.fn === "process.rows") {
-                    // Result is the module's interned `number | undefined` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "f64" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return the 'number | undefined' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.createServer" || e.fn === "http2.createServerReq") {
-                    // The request handler: void, at most (req, res) in order.
-                    const cbT = e.args[0]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
-                    if (ok && cbT?.kind === "func") {
-                        const [p0, p1] = cbT.params;
-                        if (p0 !== undefined && p0.kind !== "httpReq")
-                            ok = false;
-                        if (p1 !== undefined && p1.kind !== "httpRes")
-                            ok = false;
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} handler shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.serverOnRequest") {
-                    // The 'request' listener: the same shape as http.createServer's
-                    // handler — void, at most (req, res) in order.
-                    const cbT = e.args[1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
-                    if (ok && cbT?.kind === "func") {
-                        const [p0, p1] = cbT.params;
-                        if (p0 !== undefined && p0.kind !== "httpReq")
-                            ok = false;
-                        if (p1 !== undefined && p1.kind !== "httpRes")
-                            ok = false;
-                    }
-                    if (!ok) {
-                        err(`libCall http.serverOnRequest handler shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http2.serverOnSessionError") {
-                    const cbT = e.args[1]?.type;
-                    const ok = cbT?.kind === "func" && cbT.ret.kind === "void" &&
-                        cbT.params.length <= 2 &&
-                        (cbT.params[0] === undefined ||
-                            (cbT.params[0].kind === "object" && cbT.params[0].className === "%Error")) &&
-                        (cbT.params[1] === undefined || cbT.params[1].kind === "http2Session");
-                    if (!ok) {
-                        err(`libCall http2.serverOnSessionError callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.reqOnData") {
-                    const cbT = e.args[1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        const p = cbT.params[0];
-                        // dyn = the checked-dynamic listener's adapter (the chunk
-                        // boxes Buffer-flavored in the runtime data thunk).
-                        ok = (p.kind === "bytes" && p.elem === "u8") || p.kind === "dyn";
-                    }
-                    if (!ok) {
-                        err(`libCall http.reqOnData callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.reqStatusCode") {
-                    // Result is the module's interned `number | undefined` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "f64" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall http.reqStatusCode must return the 'number | undefined' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "net.sockRemoteAddress") {
-                    // Result is the interned `string | undefined` union (envGet's).
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "string" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall net.sockRemoteAddress must return the 'string | undefined' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "net.sockEncrypted") {
-                    // Result is the interned `boolean | undefined` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "bool" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall net.sockEncrypted must return the 'boolean | undefined' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "tls.sockAuthError") {
-                    // Result is the interned `string | null` union (Node's
-                    // authorizationError: the verify-failure code string, or null).
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "string" &&
-                        def.arms[1].kind === "nullT";
-                    if (!ok) {
-                        err(`libCall tls.sockAuthError must return the 'string | null' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.requestCb" || e.fn === "https.requestCb" ||
-                    e.fn === "http.requestUrlCb" || e.fn === "http.clientOnResponse" ||
-                    e.fn === "http.requestAgentCb" || e.fn === "https.requestAgentCb" ||
-                    e.fn === "https.requestUrlCb") {
-                    // The response listener: void, no params or exactly (res: httpReq).
-                    const cbT = e.args[e.fn === "http.requestCb" ? 7
-                        : e.fn === "https.requestCb" ? 9
-                            : e.fn === "http.requestUrlCb" || e.fn === "https.requestUrlCb" ? 3
-                                : e.fn === "http.requestAgentCb" ? 8
-                                    : e.fn === "https.requestAgentCb" ? 10
-                                        : 1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        ok = cbT.params[0].kind === "httpReq";
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.reqOnError" || e.fn === "http.clientOnError") {
-                    // The error listener: void, no params or exactly (err: %Error).
-                    const cbT = e.args[1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        const p = cbT.params[0];
-                        ok = p.kind === "object" && p.className === "%Error";
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "net.sockRead") {
-                    // Result is the interned `Buffer | null` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "bytes" && a.elem === "u8") &&
-                        def.arms.some((a) => a.kind === "nullT");
-                    if (!ok) {
-                        err(`libCall net.sockRead must return the 'Buffer | null' union`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.serverOnUpgrade" || e.fn === "http.clientOnUpgrade" ||
-                    e.fn === "http.serverOnConnect") {
-                    // (req, socket, head) or any shorter prefix, void return. The
-                    // 'connect' registration additionally admits a socket slot
-                    // that is a UNION carrying a netSocket arm (the h2 compat
-                    // listener — the emitted adapter wraps the socket there).
-                    const cbT = e.args[1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 3;
-                    if (ok && cbT?.kind === "func") {
-                        const [p0, p1, p2] = cbT.params;
-                        if (p0 !== undefined && p0.kind !== "httpReq")
-                            ok = false;
-                        if (p1 !== undefined && p1.kind !== "netSocket") {
-                            if (e.fn === "http.serverOnConnect" && p1?.kind === "union") {
-                                const def = unions.get(p1.unionId);
-                                if (!def || !def.arms.some((a) => a.kind === "netSocket"))
-                                    ok = false;
-                            }
-                            else {
-                                ok = false;
-                            }
-                        }
-                        if (p2 !== undefined && !(p2.kind === "bytes" && p2.elem === "u8"))
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkIntrinsicExpr(e) {
+        if (e.name === "module.await") {
+            if (e.args.length !== 1)
+                err("module.await takes exactly one argument", e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "promise" || a.type.inner.kind !== "void") {
+                    err(`${typeKey(a.type)} argument to module.await (needs promise<void>)`, a.loc);
+                }
+            }
+            if (e.type.kind !== "void")
+                err("module.await must be void", e.loc);
+            return;
+        }
+        if (e.name === "promise.all") {
+            // ONE argument: an array of promises whose inner type is the
+            // result's array element (or void, collapsing to promise<void>).
+            // The exact-inner-type rule is the frontend's fence; the coarse
+            // shape keeps hand-written IR honest.
+            if (e.args.length !== 1)
+                err("promise.all takes exactly one argument", e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "array" || a.type.elem.kind !== "promise") {
+                    err(`${a.type.kind} argument to promise.all (needs an array of promises)`, a.loc);
+                }
+            }
+            if (e.type.kind !== "promise")
+                err("promise.all must be promise-typed", e.loc);
+            else if (e.type.inner.kind !== "array" && e.type.inner.kind !== "void") {
+                err("promise.all result must be a promise of an array (or void)", e.loc);
+            }
+            return;
+        }
+        if (e.name === "promise.reject") {
+            // ONE argument: the %Error-rooted reason object (the rejection
+            // payload shares the thrown-Error representation — the
+            // frontend's fence pins the hierarchy; the coarse object shape
+            // keeps hand-written IR honest) or a checked-dynamic reason
+            // (the thrown-dyn representation — identity flows to catch and
+            // unhandledRejection observers). The result is the
+            // context-named promise.
+            if (e.args.length !== 1)
+                err("promise.reject takes exactly one argument", e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "object" && a.type.kind !== "dyn") {
+                    err(`${a.type.kind} argument to promise.reject (needs an Error object or a dyn reason)`, a.loc);
+                }
+            }
+            if (e.type.kind !== "promise")
+                err("promise.reject must be promise-typed", e.loc);
+            return;
+        }
+        if (e.name === "promise.resolve") {
+            // Zero args (Promise<void>) or one plain value of the result's
+            // inner type — promise arguments never reach the intrinsic
+            // (the frontend returns them as-is).
+            if (e.args.length > 1)
+                err("promise.resolve takes at most one argument", e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind === "promise") {
+                    err("promise argument to promise.resolve (identity belongs in the frontend)", a.loc);
+                }
+            }
+            if (e.type.kind !== "promise")
+                err("promise.resolve must be promise-typed", e.loc);
+            else if (e.args.length === 0 && e.type.inner.kind !== "void") {
+                err("zero-argument promise.resolve must be promise<void>", e.loc);
+            }
+            else if (e.args.length === 1 && !typeEquals(e.args[0].type, e.type.inner)) {
+                err("promise.resolve argument must be the result's inner type", e.loc);
+            }
+            return;
+        }
+        if (e.name === "promise.race") {
+            // Entries are promises; the result is the combined promise. The
+            // per-entry inner-type compatibility (equal to the result inner,
+            // one of its union arms, or a sub-union of it) is the frontend's
+            // fence; here the coarse shape keeps hand-written IR honest.
+            if (e.args.length === 0)
+                err("promise.race with no entries", e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "promise") {
+                    err(`${a.type.kind} entry in promise.race`, a.loc);
+                }
+            }
+            if (e.type.kind !== "promise")
+                err("promise.race must be promise-typed", e.loc);
+            return;
+        }
+        for (const a of e.args) {
+            checkExpr(a);
+            // Arrays/functions/records/unions stay out of console.log (and
+            // its stderr twin console.error) by design (the ambient signature
+            // accepts number|string|boolean; a union of those satisfies it,
+            // so the frontend rejects union args explicitly) — inspect
+            // formatting is unimplemented, so the backend must never see one.
+            if (a.type.kind !== "f64" && a.type.kind !== "string" && a.type.kind !== "bool") {
+                err(`${a.type.kind} argument to ${e.name}`, a.loc);
+            }
+        }
+        if (e.type.kind !== "void")
+            err(`${e.name} must be void`, e.loc);
+    }
+    function checkLibCall(e) {
+        const sig = LIB_FN_SIGS[e.fn];
+        if (!sig) {
+            err(`libCall of unknown library function "${e.fn}"`, e.loc);
+            return;
+        }
+        // emitter.emit is variadic: (recv, name) plus the event's tuple.
+        // The stream constructors (trailing option callbacks), write/end
+        // (the optional chunk/cb tail), and unpipe (the optional
+        // destination) admit a longer list the same way.
+        const variadic = e.fn === "emitter.emit" || e.fn === "emitter.emitFlex" ||
+            e.fn === "readable.new" || e.fn === "writable.new" ||
+            e.fn === "duplex.new" || e.fn === "transform.new" ||
+            e.fn === "passthrough.new" ||
+            e.fn === "readable.init" || e.fn === "writable.init" ||
+            e.fn === "duplex.init" || e.fn === "transform.init" ||
+            e.fn === "passthrough.init" ||
+            e.fn === "readable.initDyn" || e.fn === "writable.initDyn" ||
+            e.fn === "duplex.initDyn" || e.fn === "transform.initDyn" ||
+            e.fn === "passthrough.initDyn" ||
+            e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn" ||
+            e.fn === "sp.pipeline" ||
+            e.fn === "writable.write" ||
+            e.fn === "writable.writeStr" || e.fn === "writable.writeU" ||
+            e.fn === "writable.end" ||
+            e.fn === "readable.unpipe";
+        if (variadic
+            ? e.args.length < sig.argTypes.length
+            : e.args.length !== sig.argTypes.length) {
+            err(`libCall ${e.fn}: ${e.args.length} args, expected ${sig.argTypes.length}`, e.loc);
+        }
+        e.args.forEach((a, i) => {
+            checkExpr(a);
+            const want = sig.argTypes[i];
+            if (want)
+                expectType(a, want, `libCall ${e.fn} arg ${i}`);
+        });
+        if (checkLibValueCall(e))
+            return;
+        if (checkLibNetworkCall(e))
+            return;
+        if (checkLibFileCall(e))
+            return;
+        if (checkLibProcessCall(e))
+            return;
+        if (checkLibSpecialCall(e))
+            return;
+        if (checkLibStreamCall(e, sig.argTypes.length, sig.result))
+            return;
+        if (checkLibEmitterCall(e, sig.result))
+            return;
+        if (e.fn === "error.stack" || e.fn === "error.cause" || e.fn === "error.hasCause" || e.fn === "error.setCause" || e.fn === "error.defineCause" || e.fn === "error.deleteCause") {
+            const recv = e.args[0];
+            let cls = recv?.type.kind === "object" ? classes.get(recv.type.className) : undefined;
+            while (cls?.base)
+                cls = classes.get(cls.base);
+            if (cls?.name !== "%Error")
+                err(`libCall ${e.fn} receiver must be an error object`, e.loc);
+        }
+        if (e.fn === "error.ctor" || e.fn === "error.ctorOptions" || e.fn === "error.toString") {
+            const recv = e.args[0];
+            const wantErrorRoot = e.fn === "error.toString";
+            const ok = recv &&
+                isBuiltinErrorObject(recv.type) &&
+                (!wantErrorRoot || (recv.type.kind === "object" && recv.type.className === "%Error"));
+            if (!ok) {
+                err(`libCall ${e.fn} receiver must be ${wantErrorRoot ? "'%Error'" : "a builtin error class"}`, e.loc);
+            }
+        }
+        if (!typeEquals(e.type, sig.result)) {
+            err(`libCall ${e.fn} must be ${sig.result.kind}, got ${e.type.kind}`, e.loc);
+        }
+    }
+    function checkLibValueCall(e) {
+        if (e.fn === "fileHandle.read" || e.fn === "fileHandle.writeBytes" || e.fn === "fileHandle.writeStr") {
+            const inner = e.type.kind === "promise" ? e.type.inner : undefined;
+            const shape = inner?.kind === "record" ? records.get(inner.shapeId) : undefined;
+            const countName = e.fn === "fileHandle.read" ? "bytesRead" : "bytesWritten";
+            const payload = e.args[1]?.type;
+            const count = shape?.fields.find((f) => f.name === countName);
+            const buffer = shape?.fields.find((f) => f.name === "buffer");
+            const ok = shape !== undefined && !shape.tuple && shape.indexValue === undefined && shape.fields.length === 2 &&
+                count?.type.kind === "f64" && payload !== undefined && buffer !== undefined &&
+                typeEquals(buffer.type, payload);
+            if (!ok) {
+                err(`libCall ${e.fn} must return a promise of { ${countName}: number, buffer }`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "fetch.streamFrom") {
+            const t = e.args[0]?.type;
+            const ok = t?.kind === "string" ||
+                (t?.kind === "bytes" && t.elem === "u8") ||
+                (t?.kind === "array" &&
+                    canConvertToDyn(t.elem, (id) => records.get(id), (id) => unions.get(id))) ||
+                t?.kind === "dyn";
+            if (!ok) {
+                err(`libCall fetch.streamFrom arg 0: expected a supported iterable, got ${t?.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "fetch.readerRead") {
+            if (e.type.kind !== "promise" || e.type.inner.kind !== "record") {
+                err(`libCall fetch.readerRead must return a promise of a read-result record`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "fetch.responseText" || e.fn === "fetch.responseBytes") {
+            const valueType = e.fn === "fetch.responseText" ? STRING : BYTES_U8;
+            const inner = e.type.kind === "promise" ? e.type.inner : null;
+            const union = inner?.kind === "union" ? unions.get(inner.unionId) : undefined;
+            if (inner === null ||
+                (!typeEquals(inner, valueType) &&
+                    !union?.arms.some((arm) => typeEquals(arm, valueType)))) {
+                err(`libCall ${e.fn} must return a promise whose value includes ${valueType.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "string.fromCharCode" || e.fn === "string.fromCodePoint") {
+            // One packed f64[] or one bytes value (the spread form).
+            const t = e.args[0]?.type;
+            const ok = t && ((t.kind === "array" && t.elem.kind === "f64") || t.kind === "bytes");
+            if (!ok) {
+                err(`libCall ${e.fn} arg 0: expected number[] or bytes, got ${t?.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "process.envGet") {
+            // Result is the module's interned `string | undefined` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "string" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall process.envGet must return the 'string | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "process.columns" || e.fn === "process.rows") {
+            // Result is the module's interned `number | undefined` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "f64" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall ${e.fn} must return the 'number | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        return false;
+    }
+    function checkLibNetworkCall(e) {
+        if (e.fn === "http.createServer" || e.fn === "http2.createServerReq") {
+            // The request handler: void, at most (req, res) in order.
+            const cbT = e.args[0]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
+            if (ok && cbT?.kind === "func") {
+                const [p0, p1] = cbT.params;
+                if (p0 !== undefined && p0.kind !== "httpReq")
+                    ok = false;
+                if (p1 !== undefined && p1.kind !== "httpRes")
+                    ok = false;
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} handler shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.serverOnRequest") {
+            // The 'request' listener: the same shape as http.createServer's
+            // handler — void, at most (req, res) in order.
+            const cbT = e.args[1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
+            if (ok && cbT?.kind === "func") {
+                const [p0, p1] = cbT.params;
+                if (p0 !== undefined && p0.kind !== "httpReq")
+                    ok = false;
+                if (p1 !== undefined && p1.kind !== "httpRes")
+                    ok = false;
+            }
+            if (!ok) {
+                err(`libCall http.serverOnRequest handler shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http2.serverOnSessionError") {
+            const cbT = e.args[1]?.type;
+            const ok = cbT?.kind === "func" && cbT.ret.kind === "void" &&
+                cbT.params.length <= 2 &&
+                (cbT.params[0] === undefined ||
+                    (cbT.params[0].kind === "object" && cbT.params[0].className === "%Error")) &&
+                (cbT.params[1] === undefined || cbT.params[1].kind === "http2Session");
+            if (!ok) {
+                err(`libCall http2.serverOnSessionError callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.reqOnData") {
+            const cbT = e.args[1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                const p = cbT.params[0];
+                // dyn = the checked-dynamic listener's adapter (the chunk
+                // boxes Buffer-flavored in the runtime data thunk).
+                ok = (p.kind === "bytes" && p.elem === "u8") || p.kind === "dyn";
+            }
+            if (!ok) {
+                err(`libCall http.reqOnData callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.reqStatusCode") {
+            // Result is the module's interned `number | undefined` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "f64" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall http.reqStatusCode must return the 'number | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.sockRemoteAddress") {
+            // Result is the interned `string | undefined` union (envGet's).
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "string" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall net.sockRemoteAddress must return the 'string | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.sockEncrypted") {
+            // Result is the interned `boolean | undefined` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "bool" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall net.sockEncrypted must return the 'boolean | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "tls.sockAuthError") {
+            // Result is the interned `string | null` union (Node's
+            // authorizationError: the verify-failure code string, or null).
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "string" &&
+                def.arms[1].kind === "nullT";
+            if (!ok) {
+                err(`libCall tls.sockAuthError must return the 'string | null' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.requestCb" || e.fn === "https.requestCb" ||
+            e.fn === "http.requestUrlCb" || e.fn === "http.clientOnResponse" ||
+            e.fn === "http.requestAgentCb" || e.fn === "https.requestAgentCb" ||
+            e.fn === "https.requestUrlCb") {
+            // The response listener: void, no params or exactly (res: httpReq).
+            const cbT = e.args[e.fn === "http.requestCb" ? 7
+                : e.fn === "https.requestCb" ? 9
+                    : e.fn === "http.requestUrlCb" || e.fn === "https.requestUrlCb" ? 3
+                        : e.fn === "http.requestAgentCb" ? 8
+                            : e.fn === "https.requestAgentCb" ? 10
+                                : 1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                ok = cbT.params[0].kind === "httpReq";
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.reqOnError" || e.fn === "http.clientOnError") {
+            // The error listener: void, no params or exactly (err: %Error).
+            const cbT = e.args[1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                const p = cbT.params[0];
+                ok = p.kind === "object" && p.className === "%Error";
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.sockRead") {
+            // Result is the interned `Buffer | null` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "bytes" && a.elem === "u8") &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok) {
+                err(`libCall net.sockRead must return the 'Buffer | null' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.serverOnUpgrade" || e.fn === "http.clientOnUpgrade" ||
+            e.fn === "http.serverOnConnect") {
+            // (req, socket, head) or any shorter prefix, void return. The
+            // 'connect' registration additionally admits a socket slot
+            // that is a UNION carrying a netSocket arm (the h2 compat
+            // listener — the emitted adapter wraps the socket there).
+            const cbT = e.args[1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 3;
+            if (ok && cbT?.kind === "func") {
+                const [p0, p1, p2] = cbT.params;
+                if (p0 !== undefined && p0.kind !== "httpReq")
+                    ok = false;
+                if (p1 !== undefined && p1.kind !== "netSocket") {
+                    if (e.fn === "http.serverOnConnect" && p1?.kind === "union") {
+                        const def = unions.get(p1.unionId);
+                        if (!def || !def.arms.some((a) => a.kind === "netSocket"))
                             ok = false;
                     }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "net.listenOptsCb" || e.fn === "net.listenOptsReusePortCb") {
-                    const cbIndex = e.fn === "net.listenOptsReusePortCb" ? 5 : 4;
-                    const t = e.args[cbIndex]?.type;
-                    const funcOk = (x) => x?.kind === "func" && x.params.length === 0 && x.ret.kind === "void";
-                    let ok = funcOk(t);
-                    if (!ok && t?.kind === "union") {
-                        const def = unions.get(t.unionId);
-                        ok = !!def && def.arms.length === 2 && def.arms.some((a) => funcOk(a)) &&
-                            def.arms.some((a) => a.kind === "undefinedT");
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "net.connectLookup") {
-                    // The caller's resolver: (hostname: string, options: unknown,
-                    // callback: (err: <union>, addresses: <record[]>) => void) =>
-                    // void — the emitter synthesizes the answer thunk from these
-                    // types, so the structure must hold.
-                    const t = e.args[2]?.type;
-                    let ok = t?.kind === "func" && t.ret.kind === "void" && t.params.length === 3 &&
-                        t.params[0].kind === "string" && t.params[1].kind === "dyn";
-                    if (ok && t?.kind === "func") {
-                        const cbT = t.params[2];
-                        ok = cbT.kind === "func" && cbT.ret.kind === "void" && cbT.params.length === 2 &&
-                            cbT.params[0].kind === "union" &&
-                            cbT.params[1].kind === "array" && cbT.params[1].elem.kind === "record";
-                    }
-                    if (!ok) {
-                        err(`libCall net.connectLookup resolver shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.requestConn" || e.fn === "http.requestConnCb") {
-                    const dialT = e.args[0]?.type;
-                    if (!(dialT?.kind === "func" && dialT.params.length === 0 && dialT.ret.kind === "netSocket")) {
-                        err(`libCall ${e.fn} dialer shape (frontend must fence)`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "http.requestConnCb") {
-                        const cbT = e.args[6]?.type;
-                        const ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1 &&
-                            (cbT.params[0] === undefined || cbT.params[0].kind === "httpReq");
-                        if (!ok)
-                            err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "http.reqStatusMessage" || e.fn === "http.resStatusMsgGet") {
-                    // Result is the interned `string | undefined` union (reqHeader's).
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "string") &&
-                        def.arms.some((a) => a.kind === "undefinedT");
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
+                    else {
+                        ok = false;
                     }
-                    break;
                 }
-                if (e.fn === "http.resSocket") {
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def && def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "netSocket") &&
-                        def.arms.some((a) => a.kind === "nullT");
-                    if (!ok)
-                        err(`libCall http.resSocket must return the 'Socket | null' union`, e.loc);
-                    break;
+                if (p2 !== undefined && !(p2.kind === "bytes" && p2.elem === "u8"))
+                    ok = false;
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.listenOptsCb" || e.fn === "net.listenOptsReusePortCb") {
+            const cbIndex = e.fn === "net.listenOptsReusePortCb" ? 5 : 4;
+            const t = e.args[cbIndex]?.type;
+            const funcOk = (x) => x?.kind === "func" && x.params.length === 0 && x.ret.kind === "void";
+            let ok = funcOk(t);
+            if (!ok && t?.kind === "union") {
+                const def = unions.get(t.unionId);
+                ok = !!def && def.arms.length === 2 && def.arms.some((a) => funcOk(a)) &&
+                    def.arms.some((a) => a.kind === "undefinedT");
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.connectLookup") {
+            // The caller's resolver: (hostname: string, options: unknown,
+            // callback: (err: <union>, addresses: <record[]>) => void) =>
+            // void — the emitter synthesizes the answer thunk from these
+            // types, so the structure must hold.
+            const t = e.args[2]?.type;
+            let ok = t?.kind === "func" && t.ret.kind === "void" && t.params.length === 3 &&
+                t.params[0].kind === "string" && t.params[1].kind === "dyn";
+            if (ok && t?.kind === "func") {
+                const cbT = t.params[2];
+                ok = cbT.kind === "func" && cbT.ret.kind === "void" && cbT.params.length === 2 &&
+                    cbT.params[0].kind === "union" &&
+                    cbT.params[1].kind === "array" && cbT.params[1].elem.kind === "record";
+            }
+            if (!ok) {
+                err(`libCall net.connectLookup resolver shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.requestConn" || e.fn === "http.requestConnCb") {
+            const dialT = e.args[0]?.type;
+            if (!(dialT?.kind === "func" && dialT.params.length === 0 && dialT.ret.kind === "netSocket")) {
+                err(`libCall ${e.fn} dialer shape (frontend must fence)`, e.loc);
+                return true;
+            }
+            if (e.fn === "http.requestConnCb") {
+                const cbT = e.args[6]?.type;
+                const ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1 &&
+                    (cbT.params[0] === undefined || cbT.params[0].kind === "httpReq");
+                if (!ok)
+                    err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.reqStatusMessage" || e.fn === "http.resStatusMsgGet") {
+            // Result is the interned `string | undefined` union (reqHeader's).
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "string") &&
+                def.arms.some((a) => a.kind === "undefinedT");
+            if (!ok) {
+                err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.resSocket") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def && def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "netSocket") &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok)
+                err(`libCall http.resSocket must return the 'Socket | null' union`, e.loc);
+            return true;
+        }
+        if (e.fn === "http.reqH2Stream") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def && def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "http2Stream") &&
+                def.arms.some((a) => a.kind === "undefinedT");
+            if (!ok)
+                err(`libCall http.reqH2Stream must return the 'Http2Stream | undefined' union`, e.loc);
+            return true;
+        }
+        if (e.fn === "http.reqHeader" || e.fn === "http.reqTrailer" || e.fn === "http.resGetHeader" || e.fn === "http.clientGetHeader") {
+            // Result is the interned `string | undefined` union (envGet's).
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "string" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http.reqHeaderValues" || e.fn === "http.reqTrailerValues") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def && def.arms.length === 2 &&
+                def.arms[0].kind === "array" && def.arms[0].elem.kind === "string" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok)
+                err(`libCall ${e.fn} must return the 'string[] | undefined' union`, e.loc);
+            return true;
+        }
+        if (e.fn === "net.createServerCb" || e.fn === "net.serverOnConnection" ||
+            e.fn === "net.serverOnSecureConnection" ||
+            e.fn === "http.serverSetTimeoutCb" || e.fn === "http.serverOnTimeout" ||
+            e.fn === "http.clientOnSocket" ||
+            e.fn === "net.sockOnData" || e.fn === "net.serverOnError" ||
+            e.fn === "net.sockOnError") {
+            // The program-dependent listener shapes: a void closure with no
+            // params, or exactly the one supported parameter per event
+            // (socket handle / data chunk bytes / error %Error). The
+            // callback slot is arg 0 for createServerCb, arg 1 otherwise.
+            const cbT = e.args[e.fn === "net.createServerCb" ? 0 : e.fn === "http.serverSetTimeoutCb" ? 2 : 1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                const p = cbT.params[0];
+                if (e.fn === "net.sockOnData")
+                    ok = (p.kind === "bytes" && p.elem === "u8") || p.kind === "dyn";
+                else if (e.fn === "net.serverOnError" || e.fn === "net.sockOnError") {
+                    ok = p.kind === "object" && p.className === "%Error";
+                }
+                else
+                    ok = p.kind === "netSocket";
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "http2.createSecureServerSni") {
+            // The SNI callback: (servername: string, cb: (err, ctx?) => void)
+            // => void — as a bare func, or the `| undefined` union from the
+            // conditional-spread spelling (exactly two arms: the func and
+            // undefined). The cb's own params are program-interned unions
+            // (Error|null, SecureContext|undefined) whose arms the emitted
+            // answer thunk decodes; here the structural func shape is what
+            // the validator can pin.
+            const sniOk = (t) => t?.kind === "func" && t.ret.kind === "void" && t.params.length === 2 &&
+                t.params[0].kind === "string" && t.params[1].kind === "func";
+            const argT = e.args[2]?.type;
+            let ok = sniOk(argT);
+            if (!ok && argT?.kind === "union") {
+                const def = unions.get(argT.unionId);
+                ok = def !== undefined && def.arms.length === 2 &&
+                    def.arms.some((a) => a.kind === "undefinedT") &&
+                    def.arms.some((a) => sniOk(a));
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} SNI callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "dgram.onMessage" || e.fn === "dgram.onError") {
+            // The dgram listener shapes: a void closure with no params, or
+            // the per-event parameter shapes — message takes (msg: bytes<u8>
+            // [, rinfo: record]), error the one %Error param.
+            const cbT = e.args[1]?.type;
+            const maxParams = e.fn === "dgram.onMessage" ? 2 : 1;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
+            if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
+                if (e.fn === "dgram.onMessage") {
+                    const p0 = cbT.params[0];
+                    ok = p0.kind === "bytes" && p0.elem === "u8";
+                    const p1 = cbT.params[1];
+                    if (ok && p1 !== undefined)
+                        ok = p1.kind === "record";
                 }
-                if (e.fn === "http.reqH2Stream") {
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def && def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "http2Stream") &&
-                        def.arms.some((a) => a.kind === "undefinedT");
-                    if (!ok)
-                        err(`libCall http.reqH2Stream must return the 'Http2Stream | undefined' union`, e.loc);
-                    break;
+                else {
+                    const p = cbT.params[0];
+                    ok = p.kind === "object" && p.className === "%Error";
                 }
-                if (e.fn === "http.reqHeader" || e.fn === "http.reqTrailer" || e.fn === "http.resGetHeader" || e.fn === "http.clientGetHeader") {
-                    // Result is the interned `string | undefined` union (envGet's).
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "dns.lookup") {
+            // The callback: void, at most (err: Error | null, address:
+            // string, family: number).
+            const cbT = e.args[2]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 3;
+            if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
+                const p0 = cbT.params[0];
+                const def = p0.kind === "union" ? unions.get(p0.unionId) : undefined;
+                ok =
+                    def !== undefined &&
                         def.arms.length === 2 &&
-                        def.arms[0].kind === "string" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
-                    }
-                    break;
+                        def.arms.some((a) => a.kind === "nullT") &&
+                        def.arms.some((a) => a.kind === "object" && a.className === "%Error");
+                const p1 = cbT.params[1];
+                if (ok && p1 !== undefined)
+                    ok = p1.kind === "string";
+                const p2 = cbT.params[2];
+                if (ok && p2 !== undefined)
+                    ok = p2.kind === "f64";
+            }
+            if (!ok) {
+                err(`libCall dns.lookup callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        return false;
+    }
+    function checkLibFileCall(e) {
+        if (e.fn === "zlib.deflateCb" || e.fn === "zlib.inflateCb" ||
+            e.fn === "zlib.deflateRawCb" || e.fn === "zlib.inflateRawCb" ||
+            e.fn === "zlib.gzipCb" || e.fn === "zlib.gunzipCb" || e.fn === "zlib.unzipCb") {
+            const cbT = e.args[1]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
+            if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
+                const error = cbT.params[0];
+                if (error.kind !== "dyn") {
+                    const def = error.kind === "union" ? unions.get(error.unionId) : undefined;
+                    ok = def !== undefined &&
+                        def.arms.some((arm) => arm.kind === "nullT") &&
+                        def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error") &&
+                        def.arms.every((arm) => arm.kind === "nullT" || arm.kind === "undefinedT" ||
+                            (arm.kind === "object" && arm.className === "%Error"));
+                }
+            }
+            if (ok && cbT?.kind === "func" && cbT.params.length === 2) {
+                const value = cbT.params[1];
+                ok = value.kind === "dyn" || (value.kind === "bytes" && value.elem === "u8");
+            }
+            if (!ok)
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            return true;
+        }
+        if (e.fn === "fs.renameCb" ||
+            e.fn === "process.stdoutWriteBytesCb" ||
+            e.fn === "process.stderrWriteBytesCb") {
+            // The callback is void and accepts either no parameters, one
+            // checked-dynamic error slot (JS), or Error | null (optionally
+            // including undefined for an explicitly optional parameter).
+            const cbT = e.args[2]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                const p = cbT.params[0];
+                if (p.kind === "dyn") {
+                    ok = true;
                 }
-                if (e.fn === "http.reqHeaderValues" || e.fn === "http.reqTrailerValues") {
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def && def.arms.length === 2 &&
-                        def.arms[0].kind === "array" && def.arms[0].elem.kind === "string" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok)
-                        err(`libCall ${e.fn} must return the 'string[] | undefined' union`, e.loc);
-                    break;
+                else {
+                    const def = p.kind === "union" ? unions.get(p.unionId) : undefined;
+                    ok =
+                        def !== undefined &&
+                            def.arms.some((a) => a.kind === "nullT") &&
+                            def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
+                            def.arms.every((a) => a.kind === "nullT" || a.kind === "undefinedT" ||
+                                (a.kind === "object" && a.className === "%Error"));
                 }
-                if (e.fn === "net.createServerCb" || e.fn === "net.serverOnConnection" ||
-                    e.fn === "net.serverOnSecureConnection" ||
-                    e.fn === "http.serverSetTimeoutCb" || e.fn === "http.serverOnTimeout" ||
-                    e.fn === "http.clientOnSocket" ||
-                    e.fn === "net.sockOnData" || e.fn === "net.serverOnError" ||
-                    e.fn === "net.sockOnError") {
-                    // The program-dependent listener shapes: a void closure with no
-                    // params, or exactly the one supported parameter per event
-                    // (socket handle / data chunk bytes / error %Error). The
-                    // callback slot is arg 0 for createServerCb, arg 1 otherwise.
-                    const cbT = e.args[e.fn === "net.createServerCb" ? 0 : e.fn === "http.serverSetTimeoutCb" ? 2 : 1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        const p = cbT.params[0];
-                        if (e.fn === "net.sockOnData")
-                            ok = (p.kind === "bytes" && p.elem === "u8") || p.kind === "dyn";
-                        else if (e.fn === "net.serverOnError" || e.fn === "net.sockOnError") {
-                            ok = p.kind === "object" && p.className === "%Error";
-                        }
-                        else
-                            ok = p.kind === "netSocket";
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.serverAddress") {
+            // Result is the {address, family, port} record (dgram.address's
+            // check, another receiver).
+            const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
+            const ok = shape !== undefined &&
+                shape.fields.length === 3 &&
+                shape.fields[0].name === "address" && shape.fields[0].type.kind === "string" &&
+                shape.fields[1].name === "family" && shape.fields[1].type.kind === "string" &&
+                shape.fields[2].name === "port" && shape.fields[2].type.kind === "f64";
+            if (!ok) {
+                err(`libCall net.serverAddress must return the {address, family, port} record`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "dgram.address") {
+            // Result is the {address, family, port} record.
+            const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
+            const ok = shape !== undefined &&
+                shape.fields.length === 3 &&
+                shape.fields[0].name === "address" && shape.fields[0].type.kind === "string" &&
+                shape.fields[1].name === "family" && shape.fields[1].type.kind === "string" &&
+                shape.fields[2].name === "port" && shape.fields[2].type.kind === "f64";
+            if (!ok) {
+                err(`libCall dgram.address must return the {address, family, port} record`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "fs.readdirTypesSync" || e.fn === "fsp.readdirTypes") {
+            // Result: the interned Dirent record array — {%dtype: f64,
+            // name: string, parentPath: string} rows (canonical field
+            // order; the structure lowerFsReaddirTypesCall pinned).
+            const result = e.fn === "fsp.readdirTypes"
+                ? e.type.kind === "promise" ? e.type.inner : undefined
+                : e.type;
+            const shape = result?.kind === "array" && result.elem.kind === "record"
+                ? records.get(result.elem.shapeId)
+                : undefined;
+            const ok = shape !== undefined &&
+                !shape.tuple &&
+                shape.indexValue === undefined &&
+                shape.fields.length === 3 &&
+                shape.fields[0].name === "%dtype" && shape.fields[0].type.kind === "f64" &&
+                shape.fields[1].name === "name" && shape.fields[1].type.kind === "string" &&
+                shape.fields[2].name === "parentPath" && shape.fields[2].type.kind === "string";
+            if (!ok) {
+                err(`libCall ${e.fn} must return ${e.fn === "fsp.readdirTypes" ? "a promise of " : ""}the Dirent record array`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "os.networkInterfaces") {
+            // Result: a pure index-signature record whose value is
+            // `Info[] | undefined`, Info a two-record union (one arm's
+            // scopeid f64, the other's `number | undefined`) — the structure
+            // lowerOsNetworkInterfacesCall pinned.
+            const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
+            let ok = shape !== undefined && !shape.tuple && shape.fields.length === 0 && shape.indexValue !== undefined;
+            const ivDef = ok && shape.indexValue.kind === "union" ? unions.get(shape.indexValue.unionId) : undefined;
+            const arrArm = ivDef?.arms.find((a) => a.kind === "array");
+            ok = ok && ivDef !== undefined && ivDef.arms.length === 2 && arrArm !== undefined && ivDef.arms.some((a) => a.kind === "undefinedT");
+            const infoDef = ok && arrArm.kind === "array" && arrArm.elem.kind === "union" ? unions.get(arrArm.elem.unionId) : undefined;
+            ok = ok && infoDef !== undefined && infoDef.arms.length === 2 && infoDef.arms.every((a) => a.kind === "record");
+            if (!ok) {
+                err(`libCall os.networkInterfaces must return the NetworkInterfaceInfo dictionary record`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "qs.parse") {
+            // Result: a pure index-signature record whose value union
+            // carries a string arm and a string[] arm (undefined tolerated
+            // — @types/node's Dict — and f64 too: the header-family
+            // canonicalization interns every such dictionary with the
+            // number arm, type-level only) — the structure
+            // lowerQuerystringParseCall pinned.
+            const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
+            let ok = shape !== undefined && !shape.tuple && shape.fields.length === 0 && shape.indexValue !== undefined;
+            const ivDef = ok && shape.indexValue.kind === "union" ? unions.get(shape.indexValue.unionId) : undefined;
+            ok = ok && ivDef !== undefined &&
+                ivDef.arms.some((a) => a.kind === "string") &&
+                ivDef.arms.some((a) => a.kind === "array" && a.elem.kind === "string") &&
+                ivDef.arms.every((a) => a.kind === "string" || a.kind === "array" || a.kind === "undefinedT" || a.kind === "f64");
+            if (!ok) {
+                err(`libCall qs.parse must return the ParsedUrlQuery dictionary record`, e.loc);
+            }
+            return true;
+        }
+        return false;
+    }
+    function checkLibProcessCall(e) {
+        if (e.fn === "cp.execFile") {
+            const cb = e.args[2]?.type;
+            if (cb?.kind !== "func" || cb.rest === true || cb.params.length > 3 || cb.ret.kind !== "void") {
+                err(`libCall cp.execFile callback must be a non-rest void function with at most three parameters`, e.loc);
+            }
+            else {
+                const error = cb.params[0];
+                if (error !== undefined) {
+                    const def = error.kind === "union" ? unions.get(error.unionId) : undefined;
+                    if (!def || def.arms.length !== 2 ||
+                        !def.arms.some((arm) => arm.kind === "nullT") ||
+                        !def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error")) {
+                        err(`libCall cp.execFile callback error parameter must be Error | null`, e.loc);
                     }
-                    break;
                 }
-                if (e.fn === "http2.createSecureServerSni") {
-                    // The SNI callback: (servername: string, cb: (err, ctx?) => void)
-                    // => void — as a bare func, or the `| undefined` union from the
-                    // conditional-spread spelling (exactly two arms: the func and
-                    // undefined). The cb's own params are program-interned unions
-                    // (Error|null, SecureContext|undefined) whose arms the emitted
-                    // answer thunk decodes; here the structural func shape is what
-                    // the validator can pin.
-                    const sniOk = (t) => t?.kind === "func" && t.ret.kind === "void" && t.params.length === 2 &&
-                        t.params[0].kind === "string" && t.params[1].kind === "func";
-                    const argT = e.args[2]?.type;
-                    let ok = sniOk(argT);
-                    if (!ok && argT?.kind === "union") {
-                        const def = unions.get(argT.unionId);
-                        ok = def !== undefined && def.arms.length === 2 &&
-                            def.arms.some((a) => a.kind === "undefinedT") &&
-                            def.arms.some((a) => sniOk(a));
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} SNI callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
+                const stdout = cb.params[1];
+                if (stdout !== undefined && stdout.kind !== "string") {
+                    err(`libCall cp.execFile callback stdout parameter must be string`, e.loc);
                 }
-                if (e.fn === "dgram.onMessage" || e.fn === "dgram.onError") {
-                    // The dgram listener shapes: a void closure with no params, or
-                    // the per-event parameter shapes — message takes (msg: bytes<u8>
-                    // [, rinfo: record]), error the one %Error param.
-                    const cbT = e.args[1]?.type;
-                    const maxParams = e.fn === "dgram.onMessage" ? 2 : 1;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
-                    if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
-                        if (e.fn === "dgram.onMessage") {
-                            const p0 = cbT.params[0];
-                            ok = p0.kind === "bytes" && p0.elem === "u8";
-                            const p1 = cbT.params[1];
-                            if (ok && p1 !== undefined)
-                                ok = p1.kind === "record";
-                        }
-                        else {
-                            const p = cbT.params[0];
-                            ok = p.kind === "object" && p.className === "%Error";
-                        }
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
+                const stderr = cb.params[2];
+                if (stderr !== undefined && stderr.kind !== "string") {
+                    err(`libCall cp.execFile callback stderr parameter must be string`, e.loc);
                 }
-                if (e.fn === "dns.lookup") {
-                    // The callback: void, at most (err: Error | null, address:
-                    // string, family: number).
-                    const cbT = e.args[2]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 3;
-                    if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
-                        const p0 = cbT.params[0];
-                        const def = p0.kind === "union" ? unions.get(p0.unionId) : undefined;
+            }
+        }
+        if (e.fn === "child.onSpawn") {
+            const cb = e.args[1];
+            if (!cb || cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void")
+                err("child.onSpawn callback must be () => void", e.loc);
+        }
+        if (e.fn === "child.onExit" || e.fn === "child.onClose" || e.fn === "child.onError") {
+            // The listener: a closure with no params, or exactly the
+            // supported parameter shapes per event — exit takes (code:
+            // number | null) with an optional (signal: string | null)
+            // second parameter, error exactly (err: %Error).
+            const cb = e.args[1];
+            const cbT = cb?.type;
+            const maxParams = e.fn === "child.onError" ? 1 : 2;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
+            if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
+                const p = cbT.params[0];
+                if (e.fn === "child.onExit" || e.fn === "child.onClose") {
+                    const def = p.kind === "union" ? unions.get(p.unionId) : undefined;
+                    ok =
+                        def !== undefined &&
+                            def.arms.length === 2 &&
+                            def.arms[0].kind === "f64" &&
+                            def.arms[1].kind === "nullT";
+                    if (ok && cbT.params.length === 2) {
+                        const s = cbT.params[1];
+                        const sdef = s.kind === "union" ? unions.get(s.unionId) : undefined;
                         ok =
-                            def !== undefined &&
-                                def.arms.length === 2 &&
-                                def.arms.some((a) => a.kind === "nullT") &&
-                                def.arms.some((a) => a.kind === "object" && a.className === "%Error");
-                        const p1 = cbT.params[1];
-                        if (ok && p1 !== undefined)
-                            ok = p1.kind === "string";
-                        const p2 = cbT.params[2];
-                        if (ok && p2 !== undefined)
-                            ok = p2.kind === "f64";
-                    }
-                    if (!ok) {
-                        err(`libCall dns.lookup callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "zlib.deflateCb" || e.fn === "zlib.inflateCb" ||
-                    e.fn === "zlib.deflateRawCb" || e.fn === "zlib.inflateRawCb" ||
-                    e.fn === "zlib.gzipCb" || e.fn === "zlib.gunzipCb" || e.fn === "zlib.unzipCb") {
-                    const cbT = e.args[1]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
-                    if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
-                        const error = cbT.params[0];
-                        if (error.kind !== "dyn") {
-                            const def = error.kind === "union" ? unions.get(error.unionId) : undefined;
-                            ok = def !== undefined &&
-                                def.arms.some((arm) => arm.kind === "nullT") &&
-                                def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error") &&
-                                def.arms.every((arm) => arm.kind === "nullT" || arm.kind === "undefinedT" ||
-                                    (arm.kind === "object" && arm.className === "%Error"));
-                        }
-                    }
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 2) {
-                        const value = cbT.params[1];
-                        ok = value.kind === "dyn" || (value.kind === "bytes" && value.elem === "u8");
-                    }
-                    if (!ok)
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    break;
-                }
-                if (e.fn === "fs.renameCb" ||
-                    e.fn === "process.stdoutWriteBytesCb" ||
-                    e.fn === "process.stderrWriteBytesCb") {
-                    // The callback is void and accepts either no parameters, one
-                    // checked-dynamic error slot (JS), or Error | null (optionally
-                    // including undefined for an explicitly optional parameter).
-                    const cbT = e.args[2]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        const p = cbT.params[0];
-                        if (p.kind === "dyn") {
-                            ok = true;
-                        }
-                        else {
-                            const def = p.kind === "union" ? unions.get(p.unionId) : undefined;
-                            ok =
-                                def !== undefined &&
-                                    def.arms.some((a) => a.kind === "nullT") &&
-                                    def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
-                                    def.arms.every((a) => a.kind === "nullT" || a.kind === "undefinedT" ||
-                                        (a.kind === "object" && a.className === "%Error"));
-                        }
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "net.serverAddress") {
-                    // Result is the {address, family, port} record (dgram.address's
-                    // check, another receiver).
-                    const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
-                    const ok = shape !== undefined &&
-                        shape.fields.length === 3 &&
-                        shape.fields[0].name === "address" && shape.fields[0].type.kind === "string" &&
-                        shape.fields[1].name === "family" && shape.fields[1].type.kind === "string" &&
-                        shape.fields[2].name === "port" && shape.fields[2].type.kind === "f64";
-                    if (!ok) {
-                        err(`libCall net.serverAddress must return the {address, family, port} record`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "dgram.address") {
-                    // Result is the {address, family, port} record.
-                    const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
-                    const ok = shape !== undefined &&
-                        shape.fields.length === 3 &&
-                        shape.fields[0].name === "address" && shape.fields[0].type.kind === "string" &&
-                        shape.fields[1].name === "family" && shape.fields[1].type.kind === "string" &&
-                        shape.fields[2].name === "port" && shape.fields[2].type.kind === "f64";
-                    if (!ok) {
-                        err(`libCall dgram.address must return the {address, family, port} record`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "fs.readdirTypesSync" || e.fn === "fsp.readdirTypes") {
-                    // Result: the interned Dirent record array — {%dtype: f64,
-                    // name: string, parentPath: string} rows (canonical field
-                    // order; the structure lowerFsReaddirTypesCall pinned).
-                    const result = e.fn === "fsp.readdirTypes"
-                        ? e.type.kind === "promise" ? e.type.inner : undefined
-                        : e.type;
-                    const shape = result?.kind === "array" && result.elem.kind === "record"
-                        ? records.get(result.elem.shapeId)
-                        : undefined;
-                    const ok = shape !== undefined &&
-                        !shape.tuple &&
-                        shape.indexValue === undefined &&
-                        shape.fields.length === 3 &&
-                        shape.fields[0].name === "%dtype" && shape.fields[0].type.kind === "f64" &&
-                        shape.fields[1].name === "name" && shape.fields[1].type.kind === "string" &&
-                        shape.fields[2].name === "parentPath" && shape.fields[2].type.kind === "string";
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return ${e.fn === "fsp.readdirTypes" ? "a promise of " : ""}the Dirent record array`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "os.networkInterfaces") {
-                    // Result: a pure index-signature record whose value is
-                    // `Info[] | undefined`, Info a two-record union (one arm's
-                    // scopeid f64, the other's `number | undefined`) — the structure
-                    // lowerOsNetworkInterfacesCall pinned.
-                    const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
-                    let ok = shape !== undefined && !shape.tuple && shape.fields.length === 0 && shape.indexValue !== undefined;
-                    const ivDef = ok && shape.indexValue.kind === "union" ? unions.get(shape.indexValue.unionId) : undefined;
-                    const arrArm = ivDef?.arms.find((a) => a.kind === "array");
-                    ok = ok && ivDef !== undefined && ivDef.arms.length === 2 && arrArm !== undefined && ivDef.arms.some((a) => a.kind === "undefinedT");
-                    const infoDef = ok && arrArm.kind === "array" && arrArm.elem.kind === "union" ? unions.get(arrArm.elem.unionId) : undefined;
-                    ok = ok && infoDef !== undefined && infoDef.arms.length === 2 && infoDef.arms.every((a) => a.kind === "record");
-                    if (!ok) {
-                        err(`libCall os.networkInterfaces must return the NetworkInterfaceInfo dictionary record`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "qs.parse") {
-                    // Result: a pure index-signature record whose value union
-                    // carries a string arm and a string[] arm (undefined tolerated
-                    // — @types/node's Dict — and f64 too: the header-family
-                    // canonicalization interns every such dictionary with the
-                    // number arm, type-level only) — the structure
-                    // lowerQuerystringParseCall pinned.
-                    const shape = e.type.kind === "record" ? records.get(e.type.shapeId) : undefined;
-                    let ok = shape !== undefined && !shape.tuple && shape.fields.length === 0 && shape.indexValue !== undefined;
-                    const ivDef = ok && shape.indexValue.kind === "union" ? unions.get(shape.indexValue.unionId) : undefined;
-                    ok = ok && ivDef !== undefined &&
-                        ivDef.arms.some((a) => a.kind === "string") &&
-                        ivDef.arms.some((a) => a.kind === "array" && a.elem.kind === "string") &&
-                        ivDef.arms.every((a) => a.kind === "string" || a.kind === "array" || a.kind === "undefinedT" || a.kind === "f64");
-                    if (!ok) {
-                        err(`libCall qs.parse must return the ParsedUrlQuery dictionary record`, e.loc);
+                            sdef !== undefined &&
+                                sdef.arms.length === 2 &&
+                                sdef.arms.some((a) => a.kind === "string") &&
+                                sdef.arms.some((a) => a.kind === "nullT");
                     }
-                    break;
-                }
-                if (e.fn === "cp.execFile") {
-                    const cb = e.args[2]?.type;
-                    if (cb?.kind !== "func" || cb.rest === true || cb.params.length > 3 || cb.ret.kind !== "void") {
-                        err(`libCall cp.execFile callback must be a non-rest void function with at most three parameters`, e.loc);
-                    }
-                    else {
-                        const error = cb.params[0];
-                        if (error !== undefined) {
-                            const def = error.kind === "union" ? unions.get(error.unionId) : undefined;
-                            if (!def || def.arms.length !== 2 ||
-                                !def.arms.some((arm) => arm.kind === "nullT") ||
-                                !def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error")) {
-                                err(`libCall cp.execFile callback error parameter must be Error | null`, e.loc);
-                            }
-                        }
-                        const stdout = cb.params[1];
-                        if (stdout !== undefined && stdout.kind !== "string") {
-                            err(`libCall cp.execFile callback stdout parameter must be string`, e.loc);
-                        }
-                        const stderr = cb.params[2];
-                        if (stderr !== undefined && stderr.kind !== "string") {
-                            err(`libCall cp.execFile callback stderr parameter must be string`, e.loc);
-                        }
-                    }
-                }
-                if (e.fn === "child.onExit" || e.fn === "child.onClose" || e.fn === "child.onError") {
-                    // The listener: a closure with no params, or exactly the
-                    // supported parameter shapes per event — exit takes (code:
-                    // number | null) with an optional (signal: string | null)
-                    // second parameter, error exactly (err: %Error).
-                    const cb = e.args[1];
-                    const cbT = cb?.type;
-                    const maxParams = e.fn === "child.onError" ? 1 : 2;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
-                    if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
-                        const p = cbT.params[0];
-                        if (e.fn === "child.onExit" || e.fn === "child.onClose") {
-                            const def = p.kind === "union" ? unions.get(p.unionId) : undefined;
-                            ok =
-                                def !== undefined &&
-                                    def.arms.length === 2 &&
-                                    def.arms[0].kind === "f64" &&
-                                    def.arms[1].kind === "nullT";
-                            if (ok && cbT.params.length === 2) {
-                                const s = cbT.params[1];
-                                const sdef = s.kind === "union" ? unions.get(s.unionId) : undefined;
-                                ok =
-                                    sdef !== undefined &&
-                                        sdef.arms.length === 2 &&
-                                        sdef.arms.some((a) => a.kind === "string") &&
-                                        sdef.arms.some((a) => a.kind === "nullT");
-                            }
-                        }
-                        else {
-                            ok = p.kind === "object" && p.className === "%Error";
-                        }
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "writer.onDrain" || e.fn === "writer.onFinish" || e.fn === "writer.onError") {
-                    const cbT = e.args[1]?.type;
-                    const maxParams = e.fn === "writer.onError" ? 1 : 0;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        const p = cbT.params[0];
-                        ok = p.kind === "object" && p.className === "%Error";
-                    }
-                    if (!ok)
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    break;
                 }
-                if (e.fn === "process.onExit" || e.fn === "process.offExit" ||
-                    e.fn === "stdin.onData" || e.fn === "stdin.onError") {
-                    // The listener: a void closure with no params, or exactly the
-                    // one supported parameter shape per event (code number / data
-                    // chunk bytes / error %Error).
-                    const cbT = e.args[0]?.type;
-                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
-                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
-                        const p = cbT.params[0];
-                        if (e.fn === "stdin.onData")
-                            ok = p.kind === "bytes" && p.elem === "u8";
-                        else if (e.fn === "stdin.onError")
-                            ok = p.kind === "object" && p.className === "%Error";
-                        else
-                            ok = p.kind === "f64";
-                    }
-                    if (!ok) {
-                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
-                    }
-                    break;
-                }
-                if (e.fn === "spawnRes.status") {
-                    // Result is the module's interned `number | null` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "f64" &&
-                        def.arms[1].kind === "nullT";
-                    if (!ok) {
-                        err(`libCall spawnRes.status must return the 'number | null' union`, e.loc);
-                    }
-                    break;
+                else {
+                    ok = p.kind === "object" && p.className === "%Error";
                 }
-                if (e.fn === "spawnRes.signal") {
-                    // Result is the module's interned `string | null` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "string") &&
-                        def.arms.some((a) => a.kind === "nullT");
-                    if (!ok) {
-                        err(`libCall spawnRes.signal must return the 'string | null' union`, e.loc);
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "writer.onDrain" || e.fn === "writer.onFinish" || e.fn === "writer.onError") {
+            const cbT = e.args[1]?.type;
+            const maxParams = e.fn === "writer.onError" ? 1 : 0;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                const p = cbT.params[0];
+                ok = p.kind === "object" && p.className === "%Error";
+            }
+            if (!ok)
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            return true;
+        }
+        if (e.fn === "process.onExit" || e.fn === "process.offExit" ||
+            e.fn === "stdin.onData" || e.fn === "stdin.onError") {
+            // The listener: a void closure with no params, or exactly the
+            // one supported parameter shape per event (code number / data
+            // chunk bytes / error %Error).
+            const cbT = e.args[0]?.type;
+            let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
+            if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                const p = cbT.params[0];
+                if (e.fn === "stdin.onData")
+                    ok = p.kind === "bytes" && p.elem === "u8";
+                else if (e.fn === "stdin.onError")
+                    ok = p.kind === "object" && p.className === "%Error";
+                else
+                    ok = p.kind === "f64";
+            }
+            if (!ok) {
+                err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "spawnRes.status") {
+            // Result is the module's interned `number | null` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "f64" &&
+                def.arms[1].kind === "nullT";
+            if (!ok) {
+                err(`libCall spawnRes.status must return the 'number | null' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "spawnRes.signal") {
+            // Result is the module's interned `string | null` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "string") &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok) {
+                err(`libCall spawnRes.signal must return the 'string | null' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "sp.get") {
+            // Result is the interned `string | null` union (the runtime
+            // answers +1-or-NULL; the backend builds the arms).
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "string") &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok) {
+                err(`libCall sp.get must return the 'string | null' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "sp.fromPairs") {
+            const t = e.args[0]?.type;
+            const ok = t && t.kind === "array" && t.elem.kind === "array" && t.elem.elem.kind === "string";
+            if (!ok) {
+                err(`libCall sp.fromPairs arg 0: expected string[][], got ${t?.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "sym.desc" || e.fn === "sym.keyFor") {
+            // Result is the interned `string | undefined` union (the
+            // runtime answers +1-or-NULL; the backend builds the arms).
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "string") &&
+                def.arms.some((a) => a.kind === "undefinedT");
+            if (!ok) {
+                err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "spawnRes.error") {
+            // Result is the interned `%Error | undefined` union.
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
+                def.arms.some((a) => a.kind === "undefinedT");
+            if (!ok) {
+                err(`libCall spawnRes.error must return the 'Error | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "child.pid" || e.fn === "child.exitCode") {
+            // pid: the interned `number | undefined`; exitCode: `number | null`.
+            const wantUnit = e.fn === "child.pid" ? "undefinedT" : "nullT";
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "f64" &&
+                def.arms[1].kind === wantUnit;
+            if (!ok) {
+                err(`libCall ${e.fn} must return the 'number | ${wantUnit === "nullT" ? "null" : "undefined"}' union`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "net.serverCloseBind") {
+            // The bound close: (cbUnion) => netServer, cbUnion carrying a
+            // void-returning func arm (≤1 param) and the undefined arm.
+            const t = e.type;
+            const cbU = t.kind === "func" && t.params.length === 1 ? t.params[0] : null;
+            const def = cbU?.kind === "union" ? unions.get(cbU.unionId) : undefined;
+            const ok = t.kind === "func" && (t.ret.kind === "netServer" || t.ret.kind === "void") &&
+                def &&
+                def.arms.some((a) => a.kind === "func" && a.params.length <= 1 && a.ret.kind === "void") &&
+                def.arms.some((a) => a.kind === "undefinedT");
+            if (!ok) {
+                err(`libCall net.serverCloseBind must produce the bound-close func type`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "child.stdin" || e.fn === "child.stdout" || e.fn === "child.stderr") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const handleKind = e.fn === "child.stdin" ? "childWriter" : "childStream";
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === handleKind) &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok) {
+                err(`libCall ${e.fn} must return the '${e.fn === "child.stdin" ? "Writable" : "Readable"} | null' union`, e.loc);
+            }
+            return true;
+        }
+        return false;
+    }
+    function checkLibSpecialCall(e) {
+        if (e.fn === "island.castFail") {
+            // The deferred boundary failure's typed dummy: a promise (the
+            // only cast shape the frontend defers).
+            if (e.type.kind !== "promise") {
+                err(`libCall island.castFail must return a promise type, got ${e.type.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "global.undefRead") {
+            // Always throws — the result type is whatever the declared type
+            // of the undefined global mapped to (never materialized).
+            return true;
+        }
+        if (e.fn === "error.nodeThrow" || e.fn === "error.argTypeThrow" || e.fn === "error.propTypeThrow" ||
+            e.fn === "fs.mkdtempChk" || e.fn === "fs.readFileChk" ||
+            e.fn === "fs.opendirChk" || e.fn === "fs.watchFileChk" || e.fn === "fs.lchmodChk" ||
+            e.fn === "fs.readChk" || e.fn === "fs.streamOptsChk" || e.fn === "net.connectOptsChk" ||
+            e.fn === "tls.caCertsChk") {
+            // Always throws — the result type is the replaced expression's
+            // own (never materialized; the global.undefRead pattern). The
+            // fs Chk ladders qualify: every validation failure throws
+            // Node's typed error, and a full pass throws the trailing
+            // compiler-rendered fence.
+            return true;
+        }
+        if (e.fn === "error.new" || e.fn === "error.newOptions") {
+            // Which builtin the runtime constructs is named by the result type.
+            if (!isBuiltinErrorObject(e.type)) {
+                err(`libCall ${e.fn} must return a builtin error class, got ${e.type.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "error.newDom") {
+            if (e.type.kind !== "object" || e.type.className !== "%DOMException") {
+                err(`libCall error.newDom must return %DOMException, got ${e.type.kind}`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "error.domCode" || e.fn === "error.domHasCause" || e.fn === "error.domCause" || e.fn === "error.domClone") {
+            // Receiver: exactly %DOMException (subclassing is fenced — the
+            // hidden runtime slots admit no other layout).
+            const recv = e.args[0];
+            if (!recv || recv.type.kind !== "object" || recv.type.className !== "%DOMException") {
+                err(`libCall ${e.fn} receiver must be %DOMException`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "class.name") {
+            // The arg is any class value (program-dependent classval).
+            if (e.args[0]?.type.kind !== "classval") {
+                err(`libCall class.name takes a class value`, e.loc);
+            }
+            if (e.type.kind !== "string") {
+                err(`libCall class.name must return string`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "assert.refEqBytes" || e.fn === "assert.bytesDeepEq") {
+            // Both value slots: ONE static bytes type (the frontend's
+            // same-static-type gate — a u8/u32 mix would memcmp garbage).
+            const a = e.args[0]?.type;
+            const b = e.args[1]?.type;
+            if (a?.kind !== "bytes" || b === undefined || !typeEquals(a, b)) {
+                err(`libCall ${e.fn} takes two same-typed bytes values`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "assert.refEqFn") {
+            // ANY two function signatures: the compare is pointer identity.
+            if (e.args[0]?.type.kind !== "func" || e.args[1]?.type.kind !== "func") {
+                err(`libCall assert.refEqFn takes two function values`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "error.code") {
+            // Receiver: any error-hierarchy object (a user subclass embeds
+            // the code slot in its prefix); result: the interned
+            // `string | undefined` union (the process.envGet pattern).
+            const recv = e.args[0];
+            if (!recv || recv.type.kind !== "object") {
+                err(`libCall error.code receiver must be an error object`, e.loc);
+                return true;
+            }
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms[0].kind === "string" &&
+                def.arms[1].kind === "undefinedT";
+            if (!ok) {
+                err(`libCall error.code must return the 'string | undefined' union`, e.loc);
+            }
+            return true;
+        }
+        return false;
+    }
+    function checkLibStreamCall(e, fixedArgs, result) {
+        if (e.fn.startsWith("readable.") || e.fn.startsWith("writable.") ||
+            e.fn.startsWith("duplex.") || e.fn.startsWith("transform.") ||
+            e.fn.startsWith("passthrough.") || e.fn === "stream.destroy" ||
+            e.fn === "stream.destroyErr" || e.fn === "stream.iteratorClose" || e.fn === "stream.prop" ||
+            e.fn === "stream.errored" || e.fn === "stream.finished" ||
+            e.fn === "stream.finishedDyn" || e.fn === "stream.pipeline" ||
+            e.fn === "stream.pipelineDyn") {
+            // Receiver/result: stream-hierarchy objects (a class whose base
+            // chain reaches a runtime stream class). Constructors have no
+            // receiver — their RESULT names the class; chaining forms
+            // return the receiver's static type; pipe returns its
+            // destination's.
+            const isStreamObject = (t) => {
+                if (t?.kind !== "object")
+                    return false;
+                let name = t.className;
+                while (name !== undefined) {
+                    if (RUNTIME_STREAM_CLASSES.has(name))
+                        return true;
+                    name = classes.get(name)?.base;
+                }
+                return false;
+            };
+            if (e.fn.endsWith(".new")) {
+                if (!isStreamObject(e.type)) {
+                    err(`libCall ${e.fn} must return a stream class, got ${e.type.kind}`, e.loc);
+                }
+                for (let i = fixedArgs; i < e.args.length; i++) {
+                    if (e.args[i].type.kind !== "func") {
+                        err(`libCall ${e.fn} option callback ${i} must be a func`, e.loc);
                     }
-                    break;
                 }
-                if (e.fn === "sp.get") {
-                    // Result is the interned `string | null` union (the runtime
-                    // answers +1-or-NULL; the backend builds the arms).
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "string") &&
-                        def.arms.some((a) => a.kind === "nullT");
-                    if (!ok) {
-                        err(`libCall sp.get must return the 'string | null' union`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn.endsWith(".newDyn")) {
+                // The dyn-options constructor: (optsDyn) → the stream class.
+                if (!isStreamObject(e.type)) {
+                    err(`libCall ${e.fn} must return a stream class, got ${e.type.kind}`, e.loc);
                 }
-                if (e.fn === "sp.fromPairs") {
-                    const t = e.args[0]?.type;
-                    const ok = t && t.kind === "array" && t.elem.kind === "array" && t.elem.elem.kind === "string";
-                    if (!ok) {
-                        err(`libCall sp.fromPairs arg 0: expected string[][], got ${t?.kind}`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn.endsWith(".initDyn")) {
+                // (recv, optsDyn, flags, ...fallback wrapper closures).
+                if (!isStreamObject(e.args[0]?.type)) {
+                    err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
                 }
-                if (e.fn === "sym.desc" || e.fn === "sym.keyFor") {
-                    // Result is the interned `string | undefined` union (the
-                    // runtime answers +1-or-NULL; the backend builds the arms).
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "string") &&
-                        def.arms.some((a) => a.kind === "undefinedT");
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
+                for (let i = fixedArgs; i < e.args.length; i++) {
+                    if (e.args[i].type.kind !== "func") {
+                        err(`libCall ${e.fn} fallback callback ${i} must be a func`, e.loc);
                     }
-                    break;
                 }
-                if (e.fn === "spawnRes.error") {
-                    // Result is the interned `%Error | undefined` union.
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "object" && a.className === "%Error") &&
-                        def.arms.some((a) => a.kind === "undefinedT");
-                    if (!ok) {
-                        err(`libCall spawnRes.error must return the 'Error | undefined' union`, e.loc);
-                    }
-                    break;
+                if (e.type.kind !== "void")
+                    err(`libCall ${e.fn} must be void`, e.loc);
+                return true;
+            }
+            if (e.fn === "stream.finished" || e.fn === "stream.finishedDyn") {
+                // (recv, cb) → the cleanup closure.
+                if (!isStreamObject(e.args[0]?.type)) {
+                    err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
                 }
-                if (e.fn === "child.pid" || e.fn === "child.exitCode") {
-                    // pid: the interned `number | undefined`; exitCode: `number | null`.
-                    const wantUnit = e.fn === "child.pid" ? "undefinedT" : "nullT";
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "f64" &&
-                        def.arms[1].kind === wantUnit;
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return the 'number | ${wantUnit === "nullT" ? "null" : "undefined"}' union`, e.loc);
-                    }
-                    break;
+                const cbK = e.args[1]?.type.kind;
+                if (e.fn === "stream.finished" ? cbK !== "func" : cbK !== "dyn") {
+                    err(`libCall ${e.fn} callback must be ${e.fn === "stream.finished" ? "a func" : "dyn"}`, e.loc);
                 }
-                if (e.fn === "net.serverCloseBind") {
-                    // The bound close: (cbUnion) => netServer, cbUnion carrying a
-                    // void-returning func arm (≤1 param) and the undefined arm.
-                    const t = e.type;
-                    const cbU = t.kind === "func" && t.params.length === 1 ? t.params[0] : null;
-                    const def = cbU?.kind === "union" ? unions.get(cbU.unionId) : undefined;
-                    const ok = t.kind === "func" && (t.ret.kind === "netServer" || t.ret.kind === "void") &&
-                        def &&
-                        def.arms.some((a) => a.kind === "func" && a.params.length <= 1 && a.ret.kind === "void") &&
-                        def.arms.some((a) => a.kind === "undefinedT");
-                    if (!ok) {
-                        err(`libCall net.serverCloseBind must produce the bound-close func type`, e.loc);
-                    }
-                    break;
+                if (e.type.kind !== "func") {
+                    err(`libCall ${e.fn} must return the cleanup closure, got ${e.type.kind}`, e.loc);
                 }
-                if (e.fn === "child.stdin" || e.fn === "child.stdout" || e.fn === "child.stderr") {
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const handleKind = e.fn === "child.stdin" ? "childWriter" : "childStream";
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === handleKind) &&
-                        def.arms.some((a) => a.kind === "nullT");
-                    if (!ok) {
-                        err(`libCall ${e.fn} must return the '${e.fn === "child.stdin" ? "Writable" : "Readable"} | null' union`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn") {
+                // (count, s1..sn, cb) → the destination's type.
+                const count = e.args[0];
+                const n = count?.kind === "numLit" ? count.value : -1;
+                if (n < 2 || e.args.length !== n + 2) {
+                    err(`libCall ${e.fn} count/arity mismatch`, e.loc);
+                    return true;
                 }
-                if (e.fn === "island.castFail") {
-                    // The deferred boundary failure's typed dummy: a promise (the
-                    // only cast shape the frontend defers).
-                    if (e.type.kind !== "promise") {
-                        err(`libCall island.castFail must return a promise type, got ${e.type.kind}`, e.loc);
+                for (let i = 1; i <= n; i++) {
+                    if (!isStreamObject(e.args[i]?.type)) {
+                        err(`libCall ${e.fn} stage ${i} must be a stream-hierarchy object`, e.loc);
                     }
-                    break;
                 }
-                if (e.fn === "global.undefRead") {
-                    // Always throws — the result type is whatever the declared type
-                    // of the undefined global mapped to (never materialized).
-                    break;
+                const cbK = e.args[n + 1]?.type.kind;
+                if (e.fn === "stream.pipeline" ? cbK !== "func" : cbK !== "dyn") {
+                    err(`libCall ${e.fn} callback must be ${e.fn === "stream.pipeline" ? "a func" : "dyn"}`, e.loc);
                 }
-                if (e.fn === "error.nodeThrow" || e.fn === "error.argTypeThrow" || e.fn === "error.propTypeThrow" ||
-                    e.fn === "fs.mkdtempChk" || e.fn === "fs.readFileChk" ||
-                    e.fn === "fs.opendirChk" || e.fn === "fs.watchFileChk" || e.fn === "fs.lchmodChk" ||
-                    e.fn === "fs.readChk" || e.fn === "fs.streamOptsChk" || e.fn === "net.connectOptsChk" ||
-                    e.fn === "tls.caCertsChk") {
-                    // Always throws — the result type is the replaced expression's
-                    // own (never materialized; the global.undefRead pattern). The
-                    // fs Chk ladders qualify: every validation failure throws
-                    // Node's typed error, and a full pass throws the trailing
-                    // compiler-rendered fence.
-                    break;
+                if (!typeEquals(e.type, e.args[n].type)) {
+                    err(`libCall ${e.fn} must return its destination's type`, e.loc);
                 }
-                if (e.fn === "error.new") {
-                    // Which builtin the runtime constructs is named by the result type.
-                    if (!isBuiltinErrorObject(e.type)) {
-                        err(`libCall error.new must return a builtin error class, got ${e.type.kind}`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn === "readable.fromArr") {
+                // No receiver: the seed array leads; the result is the class.
+                if (e.args[0]?.type.kind !== "array" || !isStreamObject(e.type)) {
+                    err(`libCall readable.fromArr must take an array and return a stream class`, e.loc);
                 }
-                if (e.fn === "error.newDom") {
-                    if (e.type.kind !== "object" || e.type.className !== "%DOMException") {
-                        err(`libCall error.newDom must return %DOMException, got ${e.type.kind}`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (!isStreamObject(e.args[0]?.type)) {
+                err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
+                return true;
+            }
+            if (e.fn === "readable.nextChunk" || e.fn === "readable.nextChunkDyn") {
+                if (e.type.kind !== "promise") {
+                    err(`libCall ${e.fn} must return a promise, got ${e.type.kind}`, e.loc);
                 }
-                if (e.fn === "error.domCode" || e.fn === "error.domHasCause" || e.fn === "error.domCause" || e.fn === "error.domClone") {
-                    // Receiver: exactly %DOMException (subclassing is fenced — the
-                    // hidden runtime slots admit no other layout).
-                    const recv = e.args[0];
-                    if (!recv || recv.type.kind !== "object" || recv.type.className !== "%DOMException") {
-                        err(`libCall ${e.fn} receiver must be %DOMException`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn === "readable.pause" || e.fn === "readable.resume" ||
+                e.fn === "readable.unpipe" || e.fn === "writable.end" ||
+                e.fn === "readable.setEncoding" || e.fn === "readable.pushEncoding" ||
+                e.fn === "stream.destroy" || e.fn === "stream.destroyErr" ||
+                e.fn === "stream.iteratorClose") {
+                if (!typeEquals(e.type, e.args[0].type)) {
+                    err(`libCall ${e.fn} must return its receiver's type (the chaining 'this')`, e.loc);
                 }
-                if (e.fn === "class.name") {
-                    // The arg is any class value (program-dependent classval).
-                    if (e.args[0]?.type.kind !== "classval") {
-                        err(`libCall class.name takes a class value`, e.loc);
-                    }
-                    if (e.type.kind !== "string") {
-                        err(`libCall class.name must return string`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn === "readable.pipe") {
+                if (!isStreamObject(e.args[1]?.type) || !typeEquals(e.type, e.args[1].type)) {
+                    err(`libCall readable.pipe must return its destination's type`, e.loc);
                 }
-                if (e.fn === "assert.refEqBytes" || e.fn === "assert.bytesDeepEq") {
-                    // Both value slots: ONE static bytes type (the frontend's
-                    // same-static-type gate — a u8/u32 mix would memcmp garbage).
-                    const a = e.args[0]?.type;
-                    const b = e.args[1]?.type;
-                    if (a?.kind !== "bytes" || b === undefined || !typeEquals(a, b)) {
-                        err(`libCall ${e.fn} takes two same-typed bytes values`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (e.fn === "readable.read" || e.fn === "readable.flowing" || e.fn === "stream.errored") {
+                const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+                const wantArm = (t) => e.fn === "readable.read" ? t.kind === "bytes" :
+                    e.fn === "readable.flowing" ? t.kind === "bool" :
+                        t.kind === "object";
+                const ok = def && def.arms.length === 2 &&
+                    def.arms.some(wantArm) && def.arms.some((a) => a.kind === "nullT");
+                if (!ok)
+                    err(`libCall ${e.fn} must return its nullable union`, e.loc);
+                return true;
+            }
+            if (e.fn === "stream.prop") {
+                if (e.type.kind !== "bool" && e.type.kind !== "f64") {
+                    err(`libCall stream.prop must be bool or f64, got ${e.type.kind}`, e.loc);
                 }
-                if (e.fn === "assert.refEqFn") {
-                    // ANY two function signatures: the compare is pointer identity.
-                    if (e.args[0]?.type.kind !== "func" || e.args[1]?.type.kind !== "func") {
-                        err(`libCall assert.refEqFn takes two function values`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (!typeEquals(e.type, result)) {
+                err(`libCall ${e.fn} must be ${result.kind}, got ${e.type.kind}`, e.loc);
+            }
+            return true;
+        }
+        return false;
+    }
+    function checkLibEmitterCall(e, result) {
+        if ((e.fn.startsWith("emitter.") || e.fn === "stream.onDyn") && e.fn !== "emitter.setDefaultMax" &&
+            e.fn !== "emitter.setDefaultMaxChk" &&
+            e.fn !== "emitter.getDefaultMax" && e.fn !== "emitter.checkListener") {
+            // Receiver: an emitter-hierarchy object (the %EventEmitter class
+            // itself, or a class whose base chain reaches it). emitter.new
+            // has no receiver — its RESULT is the bare emitter class.
+            const isEmitterObject = (t) => {
+                if (t?.kind !== "object")
+                    return false;
+                let name = t.className;
+                while (name !== undefined) {
+                    if (name === RUNTIME_EMITTER_CLASS)
+                        return true;
+                    name = classes.get(name)?.base;
+                }
+                return false;
+            };
+            if (e.fn === "emitter.new") {
+                if (e.type.kind !== "object" || e.type.className !== RUNTIME_EMITTER_CLASS) {
+                    err(`libCall emitter.new must return '%EventEmitter', got ${e.type.kind}`, e.loc);
                 }
-                if (e.fn === "error.code") {
-                    // Receiver: any error-hierarchy object (a user subclass embeds
-                    // the code slot in its prefix); result: the interned
-                    // `string | undefined` union (the process.envGet pattern).
-                    const recv = e.args[0];
-                    if (!recv || recv.type.kind !== "object") {
-                        err(`libCall error.code receiver must be an error object`, e.loc);
-                        break;
-                    }
-                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                    const ok = def &&
-                        def.arms.length === 2 &&
-                        def.arms[0].kind === "string" &&
-                        def.arms[1].kind === "undefinedT";
-                    if (!ok) {
-                        err(`libCall error.code must return the 'string | undefined' union`, e.loc);
-                    }
-                    break;
+                return true;
+            }
+            if (!isEmitterObject(e.args[0]?.type)) {
+                err(`libCall ${e.fn} receiver must be an emitter-hierarchy object`, e.loc);
+                return true;
+            }
+            // The chaining forms return the receiver's own static class.
+            if (e.fn === "emitter.on" || e.fn === "emitter.off" ||
+                e.fn === "emitter.onDyn" || (e.fn === "emitter.onFlex" || e.fn === "stream.onDyn") || e.fn === "emitter.offDyn" ||
+                e.fn === "emitter.onData" || e.fn === "emitter.onDataDyn" ||
+                e.fn === "emitter.removeAll" || e.fn === "emitter.setMax" ||
+                e.fn === "emitter.setMaxChk") {
+                if (!typeEquals(e.type, e.args[0].type)) {
+                    err(`libCall ${e.fn} must return its receiver's type (the chaining 'this')`, e.loc);
                 }
-                if (e.fn.startsWith("readable.") || e.fn.startsWith("writable.") ||
-                    e.fn.startsWith("duplex.") || e.fn.startsWith("transform.") ||
-                    e.fn.startsWith("passthrough.") || e.fn === "stream.destroy" ||
-                    e.fn === "stream.destroyErr" || e.fn === "stream.iteratorClose" || e.fn === "stream.prop" ||
-                    e.fn === "stream.errored" || e.fn === "stream.finished" ||
-                    e.fn === "stream.finishedDyn" || e.fn === "stream.pipeline" ||
-                    e.fn === "stream.pipelineDyn") {
-                    // Receiver/result: stream-hierarchy objects (a class whose base
-                    // chain reaches a runtime stream class). Constructors have no
-                    // receiver — their RESULT names the class; chaining forms
-                    // return the receiver's static type; pipe returns its
-                    // destination's.
-                    const isStreamObject = (t) => {
-                        if (t?.kind !== "object")
-                            return false;
-                        let name = t.className;
-                        while (name !== undefined) {
-                            if (RUNTIME_STREAM_CLASSES.has(name))
-                                return true;
-                            name = classes.get(name)?.base;
-                        }
-                        return false;
-                    };
-                    if (e.fn.endsWith(".new")) {
-                        if (!isStreamObject(e.type)) {
-                            err(`libCall ${e.fn} must return a stream class, got ${e.type.kind}`, e.loc);
-                        }
-                        for (let i = sig.argTypes.length; i < e.args.length; i++) {
-                            if (e.args[i].type.kind !== "func") {
-                                err(`libCall ${e.fn} option callback ${i} must be a func`, e.loc);
-                            }
-                        }
-                        break;
-                    }
-                    if (e.fn.endsWith(".newDyn")) {
-                        // The dyn-options constructor: (optsDyn) → the stream class.
-                        if (!isStreamObject(e.type)) {
-                            err(`libCall ${e.fn} must return a stream class, got ${e.type.kind}`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn.endsWith(".initDyn")) {
-                        // (recv, optsDyn, flags, ...fallback wrapper closures).
-                        if (!isStreamObject(e.args[0]?.type)) {
-                            err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
-                        }
-                        for (let i = sig.argTypes.length; i < e.args.length; i++) {
-                            if (e.args[i].type.kind !== "func") {
-                                err(`libCall ${e.fn} fallback callback ${i} must be a func`, e.loc);
-                            }
-                        }
-                        if (e.type.kind !== "void")
-                            err(`libCall ${e.fn} must be void`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "stream.finished" || e.fn === "stream.finishedDyn") {
-                        // (recv, cb) → the cleanup closure.
-                        if (!isStreamObject(e.args[0]?.type)) {
-                            err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
-                        }
-                        const cbK = e.args[1]?.type.kind;
-                        if (e.fn === "stream.finished" ? cbK !== "func" : cbK !== "dyn") {
-                            err(`libCall ${e.fn} callback must be ${e.fn === "stream.finished" ? "a func" : "dyn"}`, e.loc);
-                        }
-                        if (e.type.kind !== "func") {
-                            err(`libCall ${e.fn} must return the cleanup closure, got ${e.type.kind}`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn") {
-                        // (count, s1..sn, cb) → the destination's type.
-                        const count = e.args[0];
-                        const n = count?.kind === "numLit" ? count.value : -1;
-                        if (n < 2 || e.args.length !== n + 2) {
-                            err(`libCall ${e.fn} count/arity mismatch`, e.loc);
-                            break;
-                        }
-                        for (let i = 1; i <= n; i++) {
-                            if (!isStreamObject(e.args[i]?.type)) {
-                                err(`libCall ${e.fn} stage ${i} must be a stream-hierarchy object`, e.loc);
-                            }
-                        }
-                        const cbK = e.args[n + 1]?.type.kind;
-                        if (e.fn === "stream.pipeline" ? cbK !== "func" : cbK !== "dyn") {
-                            err(`libCall ${e.fn} callback must be ${e.fn === "stream.pipeline" ? "a func" : "dyn"}`, e.loc);
-                        }
-                        if (!typeEquals(e.type, e.args[n].type)) {
-                            err(`libCall ${e.fn} must return its destination's type`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn === "readable.fromArr") {
-                        // No receiver: the seed array leads; the result is the class.
-                        if (e.args[0]?.type.kind !== "array" || !isStreamObject(e.type)) {
-                            err(`libCall readable.fromArr must take an array and return a stream class`, e.loc);
-                        }
-                        break;
-                    }
-                    if (!isStreamObject(e.args[0]?.type)) {
-                        err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "readable.nextChunk" || e.fn === "readable.nextChunkDyn") {
-                        if (e.type.kind !== "promise") {
-                            err(`libCall ${e.fn} must return a promise, got ${e.type.kind}`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn === "readable.pause" || e.fn === "readable.resume" ||
-                        e.fn === "readable.unpipe" || e.fn === "writable.end" ||
-                        e.fn === "readable.setEncoding" || e.fn === "readable.pushEncoding" ||
-                        e.fn === "stream.destroy" || e.fn === "stream.destroyErr" ||
-                        e.fn === "stream.iteratorClose") {
-                        if (!typeEquals(e.type, e.args[0].type)) {
-                            err(`libCall ${e.fn} must return its receiver's type (the chaining 'this')`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn === "readable.pipe") {
-                        if (!isStreamObject(e.args[1]?.type) || !typeEquals(e.type, e.args[1].type)) {
-                            err(`libCall readable.pipe must return its destination's type`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn === "readable.read" || e.fn === "readable.flowing" || e.fn === "stream.errored") {
-                        const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-                        const wantArm = (t) => e.fn === "readable.read" ? t.kind === "bytes" :
-                            e.fn === "readable.flowing" ? t.kind === "bool" :
-                                t.kind === "object";
-                        const ok = def && def.arms.length === 2 &&
-                            def.arms.some(wantArm) && def.arms.some((a) => a.kind === "nullT");
-                        if (!ok)
-                            err(`libCall ${e.fn} must return its nullable union`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "stream.prop") {
-                        if (e.type.kind !== "bool" && e.type.kind !== "f64") {
-                            err(`libCall stream.prop must be bool or f64, got ${e.type.kind}`, e.loc);
-                        }
-                        break;
-                    }
-                    if (!typeEquals(e.type, sig.result)) {
-                        err(`libCall ${e.fn} must be ${sig.result.kind}, got ${e.type.kind}`, e.loc);
-                    }
-                    break;
+                // The listener slots carry closures (the dyn family's checked-
+                // dynamic listener is table-checked; its adapter is a func).
+                if ((e.fn === "emitter.on" || e.fn === "emitter.off" || e.fn === "emitter.onData") && e.args[2]?.type.kind !== "func") {
+                    err(`libCall ${e.fn} listener must be a func`, e.loc);
                 }
-                if (e.fn.startsWith("emitter.") && e.fn !== "emitter.setDefaultMax" &&
-                    e.fn !== "emitter.setDefaultMaxChk" &&
-                    e.fn !== "emitter.getDefaultMax" && e.fn !== "emitter.checkListener") {
-                    // Receiver: an emitter-hierarchy object (the %EventEmitter class
-                    // itself, or a class whose base chain reaches it). emitter.new
-                    // has no receiver — its RESULT is the bare emitter class.
-                    const isEmitterObject = (t) => {
-                        if (t?.kind !== "object")
-                            return false;
-                        let name = t.className;
-                        while (name !== undefined) {
-                            if (name === RUNTIME_EMITTER_CLASS)
-                                return true;
-                            name = classes.get(name)?.base;
-                        }
-                        return false;
-                    };
-                    if (e.fn === "emitter.new") {
-                        if (e.type.kind !== "object" || e.type.className !== RUNTIME_EMITTER_CLASS) {
-                            err(`libCall emitter.new must return '%EventEmitter', got ${e.type.kind}`, e.loc);
-                        }
-                        break;
-                    }
-                    if (!isEmitterObject(e.args[0]?.type)) {
-                        err(`libCall ${e.fn} receiver must be an emitter-hierarchy object`, e.loc);
-                        break;
-                    }
-                    // The chaining forms return the receiver's own static class.
-                    if (e.fn === "emitter.on" || e.fn === "emitter.off" ||
-                        e.fn === "emitter.onDyn" || e.fn === "emitter.onFlex" || e.fn === "emitter.offDyn" ||
-                        e.fn === "emitter.onData" || e.fn === "emitter.onDataDyn" ||
-                        e.fn === "emitter.removeAll" || e.fn === "emitter.setMax" ||
-                        e.fn === "emitter.setMaxChk") {
-                        if (!typeEquals(e.type, e.args[0].type)) {
-                            err(`libCall ${e.fn} must return its receiver's type (the chaining 'this')`, e.loc);
-                        }
-                        // The listener slots carry closures (the dyn family's checked-
-                        // dynamic listener is table-checked; its adapter is a func).
-                        if ((e.fn === "emitter.on" || e.fn === "emitter.off" || e.fn === "emitter.onData") && e.args[2]?.type.kind !== "func") {
-                            err(`libCall ${e.fn} listener must be a func`, e.loc);
-                        }
-                        if ((e.fn === "emitter.onDyn" || e.fn === "emitter.onDataDyn") && e.args[3]?.type.kind !== "func") {
-                            err(`libCall ${e.fn} adapter must be a func`, e.loc);
-                        }
-                        break;
-                    }
-                    if (e.fn === "emitter.emitData") {
-                        const chunkT = e.args[2]?.type;
-                        const ok = chunkT !== undefined &&
-                            ((chunkT.kind === "bytes" && chunkT.elem === "u8") || chunkT.kind === "string");
-                        if (!ok)
-                            err(`libCall emitter.emitData chunk must be bytes<u8> or string`, e.loc);
-                        if (e.type.kind !== "bool")
-                            err(`libCall emitter.emitData must be bool`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "emitter.countFn" && e.args[2]?.type.kind !== "func") {
-                        err(`libCall emitter.countFn listener must be a func`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "emitter.emitError" && e.args[2]?.type.kind !== "object") {
-                        err(`libCall emitter.emitError payload must be an error-hierarchy object`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "emitter.names") {
-                        const ok = e.type.kind === "array" && e.type.elem.kind === "string";
-                        if (!ok)
-                            err(`libCall emitter.names must return string[]`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "emitter.listeners") {
-                        const ok = e.type.kind === "array" && e.type.elem.kind === "func";
-                        if (!ok)
-                            err(`libCall emitter.listeners must return a func array`, e.loc);
-                        break;
-                    }
-                    if (e.fn === "emitter.emitFlex") {
-                        if (e.args.slice(2).some((arg) => arg.type.kind !== "dyn")) {
-                            err("libCall emitter.emitFlex payloads must be checked-dynamic", e.loc);
-                        }
-                    }
-                    if (e.fn === "emitter.emit" || e.fn === "emitter.emitFlex" || e.fn === "emitter.count" ||
-                        e.fn === "emitter.getMax" || e.fn === "emitter.ctor" ||
-                        e.fn === "emitter.countFn" || e.fn === "emitter.emitError") {
-                        if (!typeEquals(e.type, sig.result)) {
-                            err(`libCall ${e.fn} must be ${sig.result.kind}, got ${e.type.kind}`, e.loc);
-                        }
-                        break;
-                    }
+                if ((e.fn === "emitter.onDyn" || e.fn === "emitter.onDataDyn") && e.args[3]?.type.kind !== "func") {
+                    err(`libCall ${e.fn} adapter must be a func`, e.loc);
                 }
-                if (e.fn === "error.ctor" || e.fn === "error.toString") {
-                    const recv = e.args[0];
-                    const wantErrorRoot = e.fn === "error.toString";
-                    const ok = recv &&
-                        isBuiltinErrorObject(recv.type) &&
-                        (!wantErrorRoot || (recv.type.kind === "object" && recv.type.className === "%Error"));
-                    if (!ok) {
-                        err(`libCall ${e.fn} receiver must be ${wantErrorRoot ? "'%Error'" : "a builtin error class"}`, e.loc);
-                    }
+                return true;
+            }
+            if (e.fn === "emitter.emitData") {
+                const chunkT = e.args[2]?.type;
+                const ok = chunkT !== undefined &&
+                    ((chunkT.kind === "bytes" && chunkT.elem === "u8") || chunkT.kind === "string");
+                if (!ok)
+                    err(`libCall emitter.emitData chunk must be bytes<u8> or string`, e.loc);
+                if (e.type.kind !== "bool")
+                    err(`libCall emitter.emitData must be bool`, e.loc);
+                return true;
+            }
+            if (e.fn === "emitter.countFn" && e.args[2]?.type.kind !== "func") {
+                err(`libCall emitter.countFn listener must be a func`, e.loc);
+                return true;
+            }
+            if (e.fn === "emitter.emitError" && e.args[2]?.type.kind !== "object") {
+                err(`libCall emitter.emitError payload must be an error-hierarchy object`, e.loc);
+                return true;
+            }
+            if (e.fn === "emitter.names") {
+                const ok = e.type.kind === "array" && e.type.elem.kind === "string";
+                if (!ok)
+                    err(`libCall emitter.names must return string[]`, e.loc);
+                return true;
+            }
+            if (e.fn === "emitter.listeners") {
+                const ok = e.type.kind === "array" && e.type.elem.kind === "func";
+                if (!ok)
+                    err(`libCall emitter.listeners must return a func array`, e.loc);
+                return true;
+            }
+            if (e.fn === "emitter.emitFlex") {
+                if (e.args.slice(2).some((arg) => arg.type.kind !== "dyn")) {
+                    err("libCall emitter.emitFlex payloads must be checked-dynamic", e.loc);
                 }
-                if (!typeEquals(e.type, sig.result)) {
-                    err(`libCall ${e.fn} must be ${sig.result.kind}, got ${e.type.kind}`, e.loc);
+            }
+            if (e.fn === "emitter.emit" || e.fn === "emitter.emitFlex" || e.fn === "emitter.count" ||
+                e.fn === "emitter.getMax" || e.fn === "emitter.ctor" ||
+                e.fn === "emitter.countFn" || e.fn === "emitter.countDyn" || e.fn === "emitter.emitError") {
+                if (!typeEquals(e.type, result)) {
+                    err(`libCall ${e.fn} must be ${result.kind}, got ${e.type.kind}`, e.loc);
                 }
-                break;
+                return true;
             }
+        }
+        return false;
+    }
+    function checkConversionExpr(e) {
+        switch (e.kind) {
             case "jsonStringify": {
                 checkExpr(e.value);
                 if (e.type.kind !== "string") {
@@ -5166,11 +5797,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // Runtime HANDLE targets unwrap the checked-dynamic tree's handle kind by tag (a
                 // retained reference, no copy — DYN_HANDLE_KINDS).
                 const handleOk = DYN_HANDLE_KINDS.has(e.type.kind);
-                if (!jsonOk(e.type) && !undefArmedOk && !bytesOk && !errorOk && !classOk && !funcOk && !handleOk) {
+                if (!canDynCheckTo(e.type, (id) => records.get(id), (id) => unions.get(id)) && !undefArmedOk && !bytesOk && !errorOk && !classOk && !funcOk && !handleOk) {
                     err(`dynCheck against non-JSON-representable type ${e.type.kind}`, e.loc);
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkAsyncExpr(e) {
+        switch (e.kind) {
             case "awaitExpr": {
                 checkExpr(e.value);
                 if (e.value.type.kind !== "promise") {
@@ -5198,7 +5837,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 // The undefined next-channel has no C value form: such yields are
                 // void-typed (statement position only — the frontend fences reads).
-                if (fn.generator.nextT.kind === "undefinedT") {
+                if (e.captureCompletion) {
+                    if (fn.async || e.type.kind !== "dyn" || !typeEquals(e.captureCompletion.returnType, fn.returnType)) {
+                        err("invalid captured generator completion", e.loc);
+                    }
+                }
+                else if (fn.generator.nextT.kind === "undefinedT") {
                     if (e.type.kind !== "void")
                         err("yield result must be void on an undefined next-channel", e.loc);
                 }
@@ -5239,7 +5883,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err("genResume throw with no payload", e.loc);
                     }
                     else if (e.arg.type.kind === "void" ||
-                        e.arg.type.kind === "dyn" ||
                         e.arg.type.kind === "caught" ||
                         e.arg.type.kind === "date") {
                         err(`genResume throw of a ${e.arg.type.kind} value`, e.loc);
@@ -5377,6 +6020,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
                 break;
             }
+            default: {
+                const _exhaustive = e;
+                void _exhaustive;
+            }
+        }
+    }
+    function checkIslandExpr(e) {
+        switch (e.kind) {
             case "jsMarshal": {
                 checkExpr(e.value);
                 if (e.type.kind !== "jsval")
@@ -5530,6 +6181,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             case "assign": {
                 const binding = locals.get(s.localId) ?? globals.get(s.localId);
+                if (s.initializes && !binding?.tdz) {
+                    err(`initializing assign requires a TDZ binding "${s.localId}"`, s.loc);
+                }
                 if (!binding)
                     err(`assign to undeclared local/global "${s.localId}"`, s.loc);
                 // Global initialization happens via assign inside %init functions,
@@ -5538,7 +6192,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // emits the init-time one. Locals keep the strict check — except a
                 // TDZ const, whose source declaration IS an assign into the
                 // scope-entry box (tsc rejects user reassignment there too).
-                else if (!binding.mutable && locals.has(s.localId) && !("tdz" in binding && binding.tdz)) {
+                else if (!binding.mutable && locals.has(s.localId) && !locals.get(s.localId)?.tdz) {
                     err(`assign to immutable local "${binding.name}"`, s.loc);
                 }
                 if (binding?.type.kind === "caught") {
@@ -5849,138 +6503,4 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         err(`non-void function may complete without returning`, fn.loc);
     }
 }
-/** Conservative "all paths return" — mirrors what tsc already guarantees. */
-function alwaysReturns(stmts, unions) {
-    for (const s of stmts) {
-        switch (s.kind) {
-            case "return":
-                return true;
-            case "throw":
-            case "rethrow":
-            case "runtimeFence":
-                // Terminates the path like return: control unwinds (to a handler or
-                // out of the function), never falling off the end. tsc agrees —
-                // `function f(): T { throw x; }` typechecks without a return.
-                return true;
-            case "exprStmt":
-                // process.exit never returns (fflush + _Exit): the path terminates
-                // like a throw. Mirrors tsc's own never-based reachability, which
-                // accepted the function without a trailing return — the
-                // parseAsync().catch entry handler ends exactly this way.
-                if (s.expr.kind === "libCall" && s.expr.fn === "process.exit")
-                    return true;
-                break;
-            case "tryCatch":
-                // Normal completion requires the try body to complete normally (and
-                // the catch, when the try raised) — if both always terminate, so
-                // does the whole statement. Without a catch, an exception keeps
-                // propagating (never a normal completion), so the try body alone
-                // decides. A finally that always terminates (throw) also decides.
-                if (alwaysReturns(s.tryBody, unions) &&
-                    (s.catchBody === null || alwaysReturns(s.catchBody, unions))) {
-                    return true;
-                }
-                if (s.finallyBody && alwaysReturns(s.finallyBody, unions))
-                    return true;
-                break;
-            case "if":
-                if (s.else_ && alwaysReturns(s.then, unions) && alwaysReturns(s.else_, unions))
-                    return true;
-                break;
-            case "while":
-                // `while (true)` with no break never completes normally (tsc treats
-                // it the same way), so anything after it is unreachable.
-                if (s.cond.kind === "boolLit" && s.cond.value && !containsBreak(s.body))
-                    return true;
-                break;
-            case "for":
-                // `for (;;)` — no condition, or a literal-true one — with no break
-                // never completes normally either (the walk-up-until-root idiom:
-                // every exit is a return).
-                if ((s.cond === null || (s.cond.kind === "boolLit" && s.cond.value)) &&
-                    !containsBreak(s.body)) {
-                    return true;
-                }
-                break;
-            case "block":
-                if (alwaysReturns(s.body, unions))
-                    return true;
-                break;
-            case "doWhile":
-                // The body runs at least once: if it returns on all paths, so does
-                // the loop. `do {} while (true)` with no break never completes.
-                if (alwaysReturns(s.body, unions))
-                    return true;
-                if (s.cond.kind === "boolLit" && s.cond.value && !containsBreak(s.body))
-                    return true;
-                break;
-            case "switch": {
-                // A switch always returns when no case body ever breaks out, every
-                // possible entry point (any case) reaches a return, and dispatch
-                // cannot miss every case: either a default exists, or the switch is
-                // an EXHAUSTIVE discriminant switch — the discriminant is a
-                // `unionDisc` over a union with N arms, every test is a distinct
-                // literal, and there are at least N of them. (At least: several
-                // discriminant VALUES can share one deduped IR arm, e.g.
-                // `{op: 0; a} | {op: 2; a}` is one record shape.) The real
-                // exhaustiveness guarantee is tsc's — it accepted the function
-                // without a trailing return (trust-the-checker, like narrowing
-                // itself); this condition only keeps hand-written IR conservative.
-                // With no switch-level breaks, execution from case i runs bodies
-                // i..end as a straight line — check that flattened suffix.
-                const hasDefault = s.cases.some((c) => c.test === null);
-                const literalTests = s.cases.map((c) => c.test).filter((t) => t !== null && (t.kind === "numLit" || t.kind === "strLit" || t.kind === "boolLit"));
-                const distinct = new Set(literalTests.map((t) => `${t.kind}:${String(t.value)}`));
-                const exhaustive = !hasDefault &&
-                    s.disc.kind === "unionDisc" &&
-                    literalTests.length === s.cases.length &&
-                    distinct.size === s.cases.length &&
-                    s.cases.length >= (unions.get(s.disc.unionId)?.arms.length ?? Infinity);
-                if (!hasDefault && !exhaustive)
-                    break;
-                if (s.cases.some((c) => containsBreak(c.body)))
-                    break;
-                const bodies = s.cases.map((c) => c.body);
-                const everyEntryReturns = bodies.every((_, i) => alwaysReturns(bodies.slice(i).flat(), unions));
-                if (everyEntryReturns)
-                    return true;
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    return false;
-}
-/** Break at this level (not inside a nested loop or switch, whose bodies
- * own their breaks). */
-function containsBreak(stmts) {
-    for (const s of stmts) {
-        switch (s.kind) {
-            case "break":
-                return true;
-            case "if":
-                if (containsBreak(s.then) || (s.else_ && containsBreak(s.else_)))
-                    return true;
-                break;
-            case "block":
-                if (containsBreak(s.body))
-                    return true;
-                break;
-            case "tryCatch":
-                // Plain try/catch does not capture breaks — a break inside binds to
-                // the enclosing loop/switch (finally-crossing jumps are rejected
-                // upstream, so reachable IR only has these in plain try/catch).
-                if (containsBreak(s.tryBody) ||
-                    (s.catchBody !== null && containsBreak(s.catchBody)) ||
-                    (s.finallyBody !== null && containsBreak(s.finallyBody))) {
-                    return true;
-                }
-                break;
-            default:
-                break; // while/for/doWhile/switch bodies own their breaks
-        }
-    }
-    return false;
-}
 //# sourceMappingURL=validate.js.map