@scriptc/compiler 0.2.4 → 0.2.6

package/dist/ir/validate.js

@@ -4,1588 +4,12 @@
  * an ICE that points at source is a gift to whoever debugs it.
  */
 import { validByteNumberToken } from "./byte-numbers.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, DYN_CLASS_PROPERTIES } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
+import { DYN_CLASS_PROPERTIES } 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
- * frontend's lib-boundary pass (lib-boundary.ts), which coerces or fences
- * checked-dynamic arguments against the same table the validator enforces. */
-export const STR_INTRINSIC_SIGS = {
-    length: { argTypes: [], minArgs: 0, result: F64 },
-    charCodeAt: { argTypes: [F64], minArgs: 1, result: F64 },
-    charAt: { argTypes: [F64], minArgs: 1, result: STRING },
-    indexOf: { argTypes: [STRING, F64], minArgs: 1, result: F64 },
-    includes: { argTypes: [STRING, F64], minArgs: 1, result: BOOL },
-    startsWith: { argTypes: [STRING, F64], minArgs: 1, result: BOOL },
-    endsWith: { argTypes: [STRING, F64], minArgs: 1, result: BOOL },
-    slice: { argTypes: [F64, F64], minArgs: 0, result: STRING },
-    substring: { argTypes: [F64, F64], minArgs: 1, result: STRING },
-    repeat: { argTypes: [F64], minArgs: 1, result: STRING },
-    trim: { argTypes: [], minArgs: 0, result: STRING },
-    trimStart: { argTypes: [], minArgs: 0, result: STRING },
-    trimEnd: { argTypes: [], minArgs: 0, result: STRING },
-    split: { argTypes: [STRING, F64], minArgs: 2, result: arrayOf(STRING) },
-    padStart: { argTypes: [F64, STRING], minArgs: 2, result: STRING },
-    padEnd: { argTypes: [F64, STRING], minArgs: 2, result: STRING },
-    toLowerCase: { argTypes: [], minArgs: 0, result: STRING },
-    toUpperCase: { argTypes: [], minArgs: 0, result: STRING },
-    normalize: { argTypes: [STRING], minArgs: 1, result: STRING },
-    isWellFormed: { argTypes: [], minArgs: 0, result: BOOL },
-    toWellFormed: { argTypes: [], minArgs: 0, result: STRING },
-    cpAt: { argTypes: [F64], minArgs: 1, result: STRING },
-};
-/** Per-method signature for regexIntrinsic. test/source/flags take the
- * regex as receiver; replace/replaceAll/split take the STRING as receiver
- * with the regex as args[0] (mirroring the source syntax). All positions
- * are required — the surface has no optionals. */
-export const REGEX_INTRINSIC_SIGS = {
-    test: { receiver: REGEX, argTypes: [STRING], result: BOOL },
-    // match's result is the program-dependent `string[] | null` union —
-    // 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) },
-};
-/** Closed-union signature table for `libCall` (mirrors ambient/scriptc.d.ts).
- * All argument positions are required — the surface has no optionals.
- * readFileSync's second argument is the (always-"utf8") encoding: it is
- * evaluated for JS-exact side-effect order and ignored by the runtime.
- * A `null` argument slot is program-dependent (a builtin-error receiver) —
- * the libCall case checks it specially, like process.envGet's result.
- * Exported for the frontend's lib-boundary pass (lib-boundary.ts). */
-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 } },
-    "abort.controllerNew": { argTypes: [], result: DYN },
-    "abort.timeout": { argTypes: [DYN], result: DYN },
-    "abort.now": { argTypes: [DYN], result: DYN },
-    "abort.any": { argTypes: [DYN], result: 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 } },
-    "fetch.abortControllerNew": { argTypes: [], result: DYN },
-    "fetch.abortTimeout": { argTypes: [DYN], result: DYN },
-    "fetch.abortNow": { argTypes: [DYN], result: DYN },
-    "fetch.abortAny": { argTypes: [DYN], result: DYN },
-    "fetch.streamNew": { argTypes: [DYN], result: DYN },
-    // 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 },
-    "island.eval": { argTypes: [STRING], result: STRING },
-    "island.import": { argTypes: [STRING, STRING, STRING], result: JSVAL },
-    "island.importDyn": { argTypes: [STRING], result: JSVAL },
-    // Result is the cast's mapped PROMISE target (program-dependent) —
-    // 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.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.promiseAll": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
-    "dyn.typeof": { argTypes: [DYN], result: STRING },
-    "dyn.objectTag": { argTypes: [DYN], result: STRING },
-    "module.registryInit": { argTypes: [F64], result: VOID },
-    "module.define": { argTypes: [F64, STRING, STRING, STRING, arrayOf(STRING), BOOL], result: VOID },
-    "module.enter": { argTypes: [F64], result: VOID },
-    "module.link": { argTypes: [F64, F64], result: VOID },
-    "module.finish": { argTypes: [F64], result: VOID },
-    "module.fail": { argTypes: [F64], result: VOID },
-    "module.filename": { argTypes: [F64], result: STRING },
-    "module.id": { argTypes: [F64], result: STRING },
-    "module.path": { argTypes: [F64], result: STRING },
-    "module.paths": { argTypes: [F64], result: arrayOf(STRING) },
-    "module.children": { argTypes: [F64], result: arrayOf(F64) },
-    "module.parent": { argTypes: [F64], result: F64 },
-    "module.loaded": { argTypes: [F64], result: BOOL },
-    "module.cacheGet": { argTypes: [STRING], result: F64 },
-    "module.cacheHas": { argTypes: [STRING], result: BOOL },
-    "module.cacheKeys": { argTypes: [], result: arrayOf(STRING) },
-    "timers.setTimeout": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: VOID },
-    "timers.setInterval": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: F64 },
-    "timers.clearInterval": { argTypes: [F64], result: VOID },
-    "timers.setTimeoutHandle": { argTypes: [{ kind: "func", params: [], ret: VOID }, F64], result: F64 },
-    "timers.clearTimeout": { argTypes: [F64], result: VOID },
-    "timers.unref": { argTypes: [F64], result: F64 },
-    "timers.ref": { argTypes: [F64], result: F64 },
-    "timers.hasRef": { argTypes: [F64], result: BOOL },
-    "timers.refresh": { argTypes: [F64], result: F64 },
-    "timers.setImmediate": { argTypes: [{ kind: "func", params: [], ret: VOID }], result: F64 },
-    "timers.queueMicrotask": { argTypes: [{ kind: "func", params: [], ret: VOID }], result: VOID },
-    "timers.queueMicrotaskDyn": { argTypes: [DYN], result: VOID },
-    "timers.clearImmediate": { argTypes: [F64], result: VOID },
-    "process.nextTick": { argTypes: [{ kind: "func", params: [], ret: VOID }], result: VOID },
-    "process.uptime": { argTypes: [], result: F64 },
-    "perf.now": { argTypes: [], result: F64 },
-    "process.availableMemory": { argTypes: [], result: F64 },
-    "process.constrainedMemory": { argTypes: [], result: F64 },
-    "process.cpuUser": { argTypes: [], result: F64 },
-    "process.cpuSystem": { argTypes: [], result: F64 },
-    "process.cpuUserDiff": { argTypes: [F64], result: F64 },
-    "process.cpuSystemDiff": { argTypes: [F64], result: F64 },
-    "process.threadCpuUser": { argTypes: [], result: F64 },
-    "process.threadCpuSystem": { argTypes: [], result: F64 },
-    "process.threadCpuUserDiff": { argTypes: [F64], result: F64 },
-    "process.threadCpuSystemDiff": { argTypes: [F64], result: F64 },
-    "process.cpuPrevValidate": { argTypes: [F64, F64], result: VOID },
-    "process.rusage": { argTypes: [F64], result: F64 },
-    "process.activeResources": { argTypes: [], result: arrayOf(STRING) },
-    "timers.immediateUnref": { argTypes: [F64], result: F64 },
-    "timers.immediateRef": { argTypes: [F64], result: F64 },
-    "timers.immediateHasRef": { argTypes: [F64], result: BOOL },
-    "timers.clearNoop": { argTypes: [], result: VOID },
-    // 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: [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 },
-    "stdin.onEnd": { argTypes: [{ kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "stdin.onError": { argTypes: [null, BOOL], result: VOID },
-    "stdin.nextChunk": { argTypes: [], result: { kind: "promise", inner: BYTES_U8 } },
-    "fs.readFileSync": { argTypes: [STRING, STRING], result: STRING },
-    "fs.readFileSyncBuf": { argTypes: [STRING], result: BYTES_U8 },
-    "fs.readFileSyncDyn": { argTypes: [STRING, DYN], result: DYN },
-    "fs.writeFileSync": { argTypes: [STRING, STRING], result: VOID },
-    "fs.appendFileSync": { argTypes: [STRING, STRING], result: VOID },
-    "fs.existsSync": { argTypes: [STRING], result: BOOL },
-    "fs.mkdirSync": { argTypes: [STRING], result: VOID },
-    "fs.rmSync": { argTypes: [STRING], result: VOID },
-    "fs.rmdirSync": { argTypes: [STRING], result: VOID },
-    "fs.readdirSync": { argTypes: [STRING], result: arrayOf(STRING) },
-    // Result is the call site's Dirent record array (VOID is the
-    // structure-checked sentinel, the os.networkInterfaces pattern).
-    "fs.readdirTypesSync": { argTypes: [STRING], result: VOID },
-    "path.join": { argTypes: [arrayOf(STRING)], result: STRING },
-    "path.resolve": { argTypes: [arrayOf(STRING)], result: STRING },
-    "path.normalize": { argTypes: [STRING], result: STRING },
-    "path.dirname": { argTypes: [STRING], result: STRING },
-    "path.basename": { argTypes: [STRING, STRING], result: STRING },
-    "path.extname": { argTypes: [STRING], result: STRING },
-    "path.isAbsolute": { argTypes: [STRING], result: BOOL },
-    "path.relative": { argTypes: [STRING, STRING], result: STRING },
-    "path.toNamespacedPath": { argTypes: [STRING], result: STRING },
-    "path.win32Join": { argTypes: [arrayOf(STRING)], result: STRING },
-    "path.win32Resolve": { argTypes: [arrayOf(STRING)], result: STRING },
-    "path.win32Normalize": { argTypes: [STRING], result: STRING },
-    "path.win32Dirname": { argTypes: [STRING], result: STRING },
-    "path.win32Basename": { argTypes: [STRING, STRING], result: STRING },
-    "path.win32Extname": { argTypes: [STRING], result: STRING },
-    "path.win32IsAbsolute": { argTypes: [STRING], result: BOOL },
-    "path.win32Relative": { argTypes: [STRING, STRING], result: STRING },
-    "path.win32ToNamespacedPath": { argTypes: [STRING], result: STRING },
-    "os.homedir": { argTypes: [], result: STRING },
-    "os.release": { argTypes: [], result: STRING },
-    "os.type": { argTypes: [], result: STRING },
-    "os.totalmem": { argTypes: [], result: F64 },
-    "process.umask": { argTypes: [F64], result: F64 },
-    "process.chdir": { argTypes: [STRING], result: VOID },
-    "process.loadEnvFile": { argTypes: [DYN], result: VOID },
-    "process.exiting": { argTypes: [], result: BOOL },
-    "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 },
-    "os.tmpdir": { argTypes: [], result: STRING },
-    // Result is the call site's Dict<NetworkInterfaceInfo[]> record (VOID is
-    // the dgram.address sentinel — the libCall case checks the structure).
-    "os.networkInterfaces": { argTypes: [], result: VOID },
-    "math.maxArr": { argTypes: [arrayOf(F64)], result: F64 },
-    "math.minArr": { argTypes: [arrayOf(F64)], result: F64 },
-    "math.hypotArr": { argTypes: [arrayOf(F64)], result: F64 },
-    "math.floor": { argTypes: [F64], result: F64 },
-    "math.abs": { argTypes: [F64], result: F64 },
-    "math.round": { argTypes: [F64], result: F64 },
-    "math.trunc": { argTypes: [F64], result: F64 },
-    "math.ceil": { argTypes: [F64], result: F64 },
-    "math.sin": { argTypes: [F64], result: F64 },
-    "math.sinh": { argTypes: [F64], result: F64 },
-    "math.cos": { argTypes: [F64], result: F64 },
-    "math.cosh": { argTypes: [F64], result: F64 },
-    "math.tan": { argTypes: [F64], result: F64 },
-    "math.tanh": { argTypes: [F64], result: F64 },
-    "math.asin": { argTypes: [F64], result: F64 },
-    "math.asinh": { argTypes: [F64], result: F64 },
-    "math.acos": { argTypes: [F64], result: F64 },
-    "math.acosh": { argTypes: [F64], result: F64 },
-    "math.atan": { argTypes: [F64], result: F64 },
-    "math.atanh": { argTypes: [F64], result: F64 },
-    "math.cbrt": { argTypes: [F64], result: F64 },
-    "math.clz32": { argTypes: [F64], result: F64 },
-    "math.sign": { argTypes: [F64], result: F64 },
-    "math.exp": { argTypes: [F64], result: F64 },
-    "math.expm1": { argTypes: [F64], result: F64 },
-    "math.fround": { argTypes: [F64], result: F64 },
-    "math.sqrt": { argTypes: [F64], result: F64 },
-    "math.log": { argTypes: [F64], result: F64 },
-    "math.log1p": { argTypes: [F64], result: F64 },
-    "math.log2": { argTypes: [F64], result: F64 },
-    "math.log10": { argTypes: [F64], result: F64 },
-    "math.atan2": { argTypes: [F64, F64], result: F64 },
-    "math.pow": { argTypes: [F64, F64], result: F64 },
-    "math.imul": { argTypes: [F64, F64], result: F64 },
-    "math.min": { argTypes: [F64, F64], result: F64 },
-    "math.max": { argTypes: [F64, F64], result: F64 },
-    "math.random": { argTypes: [], result: F64 },
-    "num.parseInt": { argTypes: [STRING, F64], result: F64 },
-    "num.parseFloat": { argTypes: [STRING], result: F64 },
-    "num.fromString": { argTypes: [STRING], result: F64 },
-    "num.isNaN": { argTypes: [F64], result: BOOL },
-    "str.encodeUriComponent": { argTypes: [STRING], result: STRING },
-    // The base64 globals: the argument is a dyn value (WebIDL ToString
-    // runs in the runtime); the zero-argument form always throws.
-    "str.atob": { argTypes: [DYN], result: STRING },
-    "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 },
-    "sym.desc": { argTypes: [SYMBOL_T], result: VOID },
-    "sym.toString": { argTypes: [SYMBOL_T], result: STRING },
-    "bigint.parse": { argTypes: [STRING], result: BIGINT_T },
-    "bigint.fromF64": { argTypes: [F64], result: BIGINT_T },
-    "bigint.neg": { argTypes: [BIGINT_T], result: BIGINT_T },
-    "bigint.not": { argTypes: [BIGINT_T], result: BIGINT_T },
-    "bigint.add": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.sub": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.mul": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.div": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.mod": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.pow": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.and": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.or": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.xor": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.shl": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.shr": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
-    "bigint.eq": { argTypes: [BIGINT_T, BIGINT_T], result: BOOL },
-    "bigint.eqString": { argTypes: [BIGINT_T, STRING], result: BOOL },
-    "bigint.cmp": { argTypes: [BIGINT_T, BIGINT_T], result: F64 },
-    "bigint.cmpNumber": { argTypes: [BIGINT_T, F64], result: F64 },
-    "bigint.truthy": { argTypes: [BIGINT_T], result: BOOL },
-    "bigint.toString": { argTypes: [BIGINT_T, F64], result: STRING },
-    "bigint.inspect": { argTypes: [BIGINT_T], result: STRING },
-    "bigint.toF64": { argTypes: [BIGINT_T], result: F64 },
-    "bigint.asUintN": { argTypes: [F64, BIGINT_T], result: BIGINT_T },
-    "bigint.asIntN": { argTypes: [F64, BIGINT_T], result: BIGINT_T },
-    "bigint.bufferRead": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: BIGINT_T },
-    "bigint.bufferWrite": { argTypes: [BYTES_U8, BIGINT_T, F64, BOOL, BOOL], result: F64 },
-    "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.canParse": { argTypes: [STRING], result: BOOL },
-    "url.canParseBase": { argTypes: [STRING, STRING], result: BOOL },
-    "url.parse": { argTypes: [STRING], result: DYN },
-    "url.parseBase": { argTypes: [STRING, STRING], result: DYN },
-    "url.protocol": { argTypes: [URL_T], result: STRING },
-    "url.origin": { argTypes: [URL_T], result: STRING },
-    "url.username": { argTypes: [URL_T], result: STRING },
-    "url.password": { argTypes: [URL_T], result: STRING },
-    "url.host": { argTypes: [URL_T], result: STRING },
-    "url.hostname": { argTypes: [URL_T], result: STRING },
-    "url.port": { argTypes: [URL_T], result: STRING },
-    "url.pathname": { argTypes: [URL_T], result: STRING },
-    "url.href": { argTypes: [URL_T], result: STRING },
-    "url.set": { argTypes: [URL_T, STRING, STRING], result: VOID },
-    "url.setChecked": { argTypes: [URL_T, STRING, DYN], result: VOID },
-    "url.fileURLToPathUrl": { argTypes: [URL_T], result: STRING },
-    "url.fileURLToPathChecked": { argTypes: [DYN], result: STRING },
-    "url.fileURLToPathOptions": { argTypes: [DYN, DYN], result: STRING },
-    "url.fileURLToPathBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
-    "url.pathToFileURLChecked": { argTypes: [DYN, DYN], result: URL_T },
-    "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
-    // generic array-of slot has no named constant here).
-    "sp.fromPairs": { argTypes: [null], result: SEARCH_PARAMS_T },
-    "sp.with": { argTypes: [SEARCH_PARAMS_T, STRING, STRING], result: SEARCH_PARAMS_T },
-    "url.searchParams": { argTypes: [URL_T], result: SEARCH_PARAMS_T },
-    "url.search": { argTypes: [URL_T], result: STRING },
-    "url.hash": { argTypes: [URL_T], result: STRING },
-    // Result is the interned `string | null` union — the libCall case
-    // checks the arms (the spawnRes.signal pattern).
-    "sp.get": { argTypes: [SEARCH_PARAMS_T, STRING], result: VOID },
-    "sp.getAll": { argTypes: [SEARCH_PARAMS_T, STRING], result: arrayOf(STRING) },
-    "sp.append": { argTypes: [SEARCH_PARAMS_T, STRING, STRING], result: VOID },
-    "sp.set": { argTypes: [SEARCH_PARAMS_T, STRING, STRING], result: VOID },
-    "sp.delete": { argTypes: [SEARCH_PARAMS_T, STRING], result: VOID },
-    "sp.deleteValue": { argTypes: [SEARCH_PARAMS_T, STRING, STRING], result: VOID },
-    "sp.has": { argTypes: [SEARCH_PARAMS_T, STRING], result: BOOL },
-    "sp.hasValue": { argTypes: [SEARCH_PARAMS_T, STRING, STRING], result: BOOL },
-    "sp.sort": { argTypes: [SEARCH_PARAMS_T], result: VOID },
-    "sp.size": { argTypes: [SEARCH_PARAMS_T], result: F64 },
-    "sp.toString": { argTypes: [SEARCH_PARAMS_T], result: STRING },
-    "sp.keyAt": { argTypes: [SEARCH_PARAMS_T, F64], result: STRING },
-    "sp.valAt": { argTypes: [SEARCH_PARAMS_T, F64], result: STRING },
-    // node:querystring. qs.parse's result is the call site's ParsedUrlQuery
-    // dictionary record (VOID is the networkInterfaces sentinel — the
-    // libCall case checks the structure); qs.stringify's object argument
-    // is a dyn value (the frontend dynFroms typed records).
-    "qs.parse": { argTypes: [STRING, STRING, STRING, F64], result: VOID },
-    "qs.stringify": { argTypes: [DYN, STRING, STRING], result: STRING },
-    "qs.escape": { argTypes: [STRING], result: STRING },
-    "qs.unescape": { argTypes: [STRING], result: STRING },
-    "util.parseArgs": { argTypes: [DYN], result: DYN },
-    "util.parseEnv": { argTypes: [DYN], result: DYN },
-    "util.getSystemErrorName": { argTypes: [DYN], result: STRING },
-    "util.getSystemErrorMessage": { argTypes: [DYN], result: STRING },
-    "util.systemErrorEntries": { argTypes: [], result: DYN },
-    "util.stripVTControlCharacters": { argTypes: [DYN], result: STRING },
-    "util.toUSVString": { argTypes: [DYN], result: STRING },
-    "util.isDeepStrictEqual": { argTypes: [DYN, DYN, DYN], result: BOOL },
-    "util.styleText": { argTypes: [DYN, DYN, DYN], result: STRING },
-    "util.typeIs": { argTypes: [DYN, STRING], result: BOOL },
-    "util.typeValue": { argTypes: [DYN, STRING], result: DYN },
-    "fs.statSync": { argTypes: [STRING], result: STATS_T },
-    "fs.lstatSync": { argTypes: [STRING], result: STATS_T },
-    "fs.fstatSync": { argTypes: [F64], result: STATS_T },
-    "fs.fchmodSync": { argTypes: [F64, F64], result: VOID },
-    "fs.fsyncSync": { argTypes: [F64], result: VOID },
-    "fs.fdatasyncSync": { argTypes: [F64], result: VOID },
-    "fs.ftruncateSync": { argTypes: [F64, F64], result: VOID },
-    "fs.utimesSync": { argTypes: [DYN, DYN, DYN], result: VOID },
-    "fs.futimesSync": { argTypes: [DYN, DYN, DYN], result: VOID },
-    "fs.lutimesSync": { argTypes: [DYN, DYN, DYN], result: VOID },
-    "fs.readvSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
-    "fs.writevSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
-    "fs.linkSync": { argTypes: [DYN, DYN], result: VOID },
-    "fs.symlinkSync": { argTypes: [DYN, DYN, DYN], result: VOID },
-    "fs.readlinkSync": { argTypes: [DYN, DYN], result: DYN },
-    "fs.statfsSync": { argTypes: [DYN, DYN], result: DYN },
-    "fs.readlinkSyncStr": { argTypes: [DYN, DYN], result: STRING },
-    "fs.readlinkSyncBuffer": { argTypes: [DYN, DYN], result: BYTES_U8 },
-    "fs.openSync": { argTypes: [STRING, STRING], result: F64 },
-    "fs.openNumericSync": { argTypes: [STRING, F64, F64], result: F64 },
-    "fs.readSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
-    "fs.writeSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
-    "fs.writeStrSync": { argTypes: [F64, STRING, F64, STRING], result: F64 },
-    // fs.watch's callback func type is program-dependent (zero params, or
-    // the eventType string) — the slot pins arity and the path/receiver.
-    "fs.watch": { argTypes: [STRING], result: FSWATCHER_T },
-    "fs.watchCb": { argTypes: [STRING, null], result: FSWATCHER_T },
-    "watcher.close": { argTypes: [FSWATCHER_T], result: VOID },
-    "crypto.x509Fingerprint": { argTypes: [BYTES_U8], result: STRING },
-    "crypto.x509FingerprintStr": { argTypes: [STRING], result: STRING },
-    "crypto.x509ValidFrom": { argTypes: [BYTES_U8], result: STRING },
-    "crypto.x509ValidFromStr": { argTypes: [STRING], result: STRING },
-    "crypto.x509ValidTo": { argTypes: [BYTES_U8], result: STRING },
-    "crypto.x509ValidToStr": { argTypes: [STRING], result: STRING },
-    "fs.closeSync": { argTypes: [F64], result: VOID },
-    "stats.isFile": { argTypes: [STATS_T], result: BOOL },
-    "stats.isDirectory": { argTypes: [STATS_T], result: BOOL },
-    "stats.isSymbolicLink": { argTypes: [STATS_T], result: BOOL },
-    "stats.size": { argTypes: [STATS_T], result: F64 },
-    "stats.dev": { argTypes: [STATS_T], result: F64 },
-    "stats.ino": { argTypes: [STATS_T], result: F64 },
-    "stats.blocks": { argTypes: [STATS_T], result: F64 },
-    "stats.nlink": { argTypes: [STATS_T], result: F64 },
-    "stats.atimeMs": { argTypes: [STATS_T], result: F64 },
-    "stats.mtimeMs": { argTypes: [STATS_T], result: F64 },
-    "stats.ctimeMs": { argTypes: [STATS_T], result: F64 },
-    // The wider sync fs slice (unlink/chmod/chown/copyfile and the
-    // mode-carrying write/mkdir forms).
-    "fs.unlinkSync": { argTypes: [STRING], result: VOID },
-    "fs.chmodSync": { argTypes: [STRING, F64], result: VOID },
-    "fs.chownSync": { argTypes: [STRING, F64, F64], result: VOID },
-    "fs.copyFileSync": { argTypes: [STRING, STRING], result: VOID },
-    "fs.renameSync": { argTypes: [STRING, STRING], result: VOID },
-    // Callback type is program-dependent (zero params or Error | null).
-    "fs.renameCb": { argTypes: [STRING, STRING, null], result: VOID },
-    "fs.writeFileModeSync": { argTypes: [STRING, STRING, F64], result: VOID },
-    "fs.mkdirModeSync": { argTypes: [STRING, F64], result: VOID },
-    "fs.mkdirRecursiveModeSync": { argTypes: [STRING, F64], result: VOID },
-    // Atomics.wait over an Int32Array — the synchronous-sleep idiom.
-    "atomics.wait": { argTypes: [bytesOf("i32"), F64, F64, F64], result: STRING },
-    "cp.spawnSync": { argTypes: [STRING, arrayOf(STRING)], result: SPAWNRES_T },
-    // spawnSync's options form: timeout, killSignal name ("" = SIGTERM),
-    // and the three stdio modes.
-    "cp.spawnSyncOpts": {
-        argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64],
-        result: SPAWNRES_T,
-    },
-    "cp.spawnSyncStdioStr": {
-        argTypes: [STRING, arrayOf(STRING), F64, STRING, STRING],
-        result: SPAWNRES_T,
-    },
-    // node:net (scr_net.c). Listener slots are program-dependent closures —
-    // null slots, checked in the libCall case (the child.onExit precedent);
-    // the zero-param callbacks pin the exact func type here. The trailing
-    // BOOL on registrations is the once flag.
-    "net.createServer": { argTypes: [], result: NETSERVER_T },
-    "net.createServerCb": { argTypes: [null], result: NETSERVER_T },
-    "net.listen": { argTypes: [NETSERVER_T, F64], result: VOID },
-    "net.listenCb": { argTypes: [NETSERVER_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "net.listenOpts": { argTypes: [NETSERVER_T, F64, STRING, BOOL], result: VOID },
-    // The callback slot is a zero-param void closure OR its
-    // `(() => void) | undefined` optional-binding union (checked specially).
-    "net.listenOptsCb": { argTypes: [NETSERVER_T, F64, STRING, BOOL, null], result: VOID },
-    "net.listenOptsReusePort": { argTypes: [NETSERVER_T, F64, STRING, BOOL, BOOL], result: VOID },
-    // The callback is a zero-param void closure OR its optional-binding union;
-    // the callback follows the reusePort BOOL in this additive ABI.
-    "net.listenOptsReusePortCb": { argTypes: [NETSERVER_T, F64, STRING, BOOL, BOOL, null], result: VOID },
-    "net.serverPort": { argTypes: [NETSERVER_T], result: F64 },
-    "net.serverListening": { argTypes: [NETSERVER_T], result: BOOL },
-    // net.serverAddress's record result is shape-checked in the libCall case
-    // (the dgram.address sentinel pattern).
-    "net.serverAddress": { argTypes: [NETSERVER_T], result: VOID },
-    "net.serverClose": { argTypes: [NETSERVER_T], result: VOID },
-    "net.serverCloseCb": { argTypes: [NETSERVER_T, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "net.serverOnError": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "net.serverOnClose": { argTypes: [NETSERVER_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "net.serverOnConnection": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "net.serverOnSecureConnection": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "net.connect": { argTypes: [F64, STRING], result: NETSOCKET_T },
-    "net.connectAttempt": { argTypes: [F64, STRING, DYN], result: NETSOCKET_T },
-    "net.connectOptsChk": { argTypes: [DYN, STRING], result: VOID },
-    "net.connectCb": { argTypes: [F64, STRING, { kind: "func", params: [], ret: VOID }], result: NETSOCKET_T },
-    // The lookup's exact func shape is program data (its answer callback's
-    // union/record types) — checked specially in the libCall case.
-    "net.connectLookup": { argTypes: [F64, STRING, null], result: NETSOCKET_T },
-    "net.sockWrite": { argTypes: [NETSOCKET_T, STRING], result: VOID },
-    "net.sockWriteBytes": { argTypes: [NETSOCKET_T, BYTES_U8], result: VOID },
-    "net.sockEnd": { argTypes: [NETSOCKET_T], result: VOID },
-    "net.sockEndStr": { argTypes: [NETSOCKET_T, STRING], result: VOID },
-    "net.sockEndBytes": { argTypes: [NETSOCKET_T, BYTES_U8], result: VOID },
-    "net.sockWriteDyn": { argTypes: [NETSOCKET_T, DYN], result: VOID },
-    "net.sockEndDyn": { argTypes: [NETSOCKET_T, DYN], result: VOID },
-    "net.sockDestroy": { argTypes: [NETSOCKET_T], result: VOID },
-    "net.sockPipe": { argTypes: [NETSOCKET_T, NETSOCKET_T], result: VOID },
-    "net.sockPipeRes": { argTypes: [NETSOCKET_T, HTTPRES_T], result: VOID },
-    "net.sockOnData": { argTypes: [NETSOCKET_T, null, BOOL], result: VOID },
-    "net.sockOnEnd": { argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "net.sockOnClose": { argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "net.sockOnError": { argTypes: [NETSOCKET_T, null, BOOL], result: VOID },
-    "net.sockOnConnect": { argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    // node:dgram + node:dns (scr_dgram.c). The message/error listeners and
-    // dns.lookup's callback are program-dependent closures (null slots,
-    // checked in the libCall case); dgram.address's record result is
-    // program-dependent too (VOID here is the envGet sentinel — the libCall
-    // case checks the {address, family, port} shape).
-    "dgram.createSocket": { argTypes: [BOOL], result: DGRAMSOCK_T },
-    "dgram.bind": { argTypes: [DGRAMSOCK_T, F64, STRING], result: VOID },
-    "dgram.bindCb": { argTypes: [DGRAMSOCK_T, F64, STRING, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "dgram.connect": { argTypes: [DGRAMSOCK_T, F64, STRING], result: VOID },
-    "dgram.connectCb": { argTypes: [DGRAMSOCK_T, F64, STRING, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "dgram.sendStr": { argTypes: [DGRAMSOCK_T, STRING, F64, STRING], result: VOID },
-    "dgram.sendBytes": { argTypes: [DGRAMSOCK_T, BYTES_U8, F64, STRING], result: VOID },
-    "dgram.sendChk": { argTypes: [DGRAMSOCK_T, DYN, DYN, DYN, DYN, DYN, STRING], result: VOID },
-    "dgram.address": { argTypes: [DGRAMSOCK_T], result: VOID },
-    "dgram.close": { argTypes: [DGRAMSOCK_T], result: VOID },
-    "dgram.closeCb": { argTypes: [DGRAMSOCK_T, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "dgram.unref": { argTypes: [DGRAMSOCK_T], result: VOID },
-    "dgram.ref": { argTypes: [DGRAMSOCK_T], result: VOID },
-    "dgram.onMessage": { argTypes: [DGRAMSOCK_T, null, BOOL], result: VOID },
-    "dgram.onError": { argTypes: [DGRAMSOCK_T, null, BOOL], result: VOID },
-    "dgram.onListening": { argTypes: [DGRAMSOCK_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "dgram.onClose": { argTypes: [DGRAMSOCK_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "dgram.onConnect": { argTypes: [DGRAMSOCK_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "dns.lookup": { argTypes: [STRING, F64, null], result: VOID },
-    // node:test (scr_test.c). Bodies are program-dependent closures (0 or
-    // 1 testCtx param, void or Promise<void> result — the spoke pinned the
-    // shape): null slots. sub's result is the settled Promise<void> the
-    // await consumes.
-    "test.register": { argTypes: [STRING, F64, STRING, null, F64, STRING], result: VOID },
-    "test.registerEmpty": { argTypes: [STRING, F64, STRING, F64, STRING], result: VOID },
-    "test.suite": { argTypes: [STRING, F64, STRING, { kind: "func", params: [], ret: VOID }, STRING], result: VOID },
-    "test.hook": { argTypes: [F64, null, F64], result: VOID },
-    "test.sub": { argTypes: [TESTCTX_T, STRING, F64, STRING, null, F64, STRING], result: { kind: "promise", inner: VOID } },
-    "test.subEmpty": { argTypes: [TESTCTX_T, STRING, F64, STRING, STRING], result: VOID },
-    "test.ctxSkip": { argTypes: [TESTCTX_T, STRING], result: VOID },
-    "test.ctxTodo": { argTypes: [TESTCTX_T, STRING], result: VOID },
-    "test.ctxDiagnostic": { argTypes: [TESTCTX_T, STRING], result: VOID },
-    "test.ctxName": { argTypes: [TESTCTX_T], result: STRING },
-    // node:http (scr_http.c over scr_net.c). The handler and the data
-    // listeners are program-dependent closures (null slots, checked in the
-    // libCall case); reqHeader's result is the interned string|undefined
-    // union, checked like process.envGet.
-    "http.createServer": { argTypes: [null], result: NETSERVER_T },
-    "http.createServerEmpty": { argTypes: [], result: NETSERVER_T },
-    "http.validateHeaderName": { argTypes: [STRING, STRING], result: VOID },
-    "http.validateHeaderValue": { argTypes: [STRING, DYN], result: VOID },
-    "http.serverJoinDupHeaders": { argTypes: [NETSERVER_T], result: VOID },
-    "http.serverAllowMissingHostHeader": { argTypes: [NETSERVER_T], result: VOID },
-    "http.serverTimeoutGet": { argTypes: [NETSERVER_T, F64], result: F64 },
-    "http.serverSetTimeout": { argTypes: [NETSERVER_T, F64], result: VOID },
-    "http.serverSetTimeoutCb": { argTypes: [NETSERVER_T, F64, null], result: VOID },
-    "http.serverOnTimeout": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "http.serverCloseAllConnections": { argTypes: [NETSERVER_T], result: VOID },
-    "http.serverCloseIdleConnections": { argTypes: [NETSERVER_T], result: VOID },
-    "http.serverTimeoutSet": { argTypes: [NETSERVER_T, F64, F64], result: VOID },
-    "http.serverTimeoutOptionSet": { argTypes: [NETSERVER_T, F64, DYN], result: VOID },
-    "net.serverOnListening": { argTypes: [NETSERVER_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.resStatusGet": { argTypes: [HTTPRES_T], result: F64 },
-    "http.resStatusSet": { argTypes: [HTTPRES_T, F64], result: VOID },
-    "http.resStatusMsgGet": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resStatusMsgSet": { argTypes: [HTTPRES_T, STRING], result: VOID },
-    "http.resRequest": { argTypes: [HTTPRES_T], result: HTTPREQ_T },
-    "http.resSocket": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resWritableFinished": { argTypes: [HTTPRES_T], result: BOOL },
-    "http.resSendDateGet": { argTypes: [HTTPRES_T], result: BOOL },
-    "http.resSendDateSet": { argTypes: [HTTPRES_T, BOOL], result: VOID },
-    "http.resStrictContentLengthGet": { argTypes: [HTTPRES_T], result: BOOL },
-    "http.resStrictContentLengthSet": { argTypes: [HTTPRES_T, BOOL], result: VOID },
-    "http.resSetTimeout": { argTypes: [HTTPRES_T, F64], result: VOID },
-    "http.resSetTimeoutCb": { argTypes: [HTTPRES_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
-    // resGetHeader answers the interned `string | undefined` union — the
-    // reqHeader/envGet sentinel pattern (VOID here, checked specially).
-    "http.resGetHeader": { argTypes: [HTTPRES_T, STRING], result: VOID },
-    "http.resGetHeaderNames": { argTypes: [HTTPRES_T], result: arrayOf(STRING) },
-    "http.resGetRawHeaderNames": { argTypes: [HTTPRES_T], result: arrayOf(STRING) },
-    "http.resGetHeaders": { argTypes: [HTTPRES_T], result: DYN },
-    "http.resHasHeader": { argTypes: [HTTPRES_T, STRING], result: BOOL },
-    "http.resRemoveHeader": { argTypes: [HTTPRES_T, STRING], result: VOID },
-    "http.resOnFinish": { argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "http.reqUrl": { argTypes: [HTTPREQ_T], result: STRING },
-    "http.reqMethod": { argTypes: [HTTPREQ_T], result: STRING },
-    "http.reqHeader": { argTypes: [HTTPREQ_T, STRING], result: VOID },
-    "http.reqTrailer": { argTypes: [HTTPREQ_T, STRING], result: VOID },
-    "http.reqHeaderValues": { argTypes: [HTTPREQ_T, STRING], result: VOID },
-    "http.reqTrailerValues": { argTypes: [HTTPREQ_T, STRING], result: VOID },
-    "http.reqOnData": { argTypes: [HTTPREQ_T, null, BOOL], result: VOID },
-    "http.reqOnEnd": { argTypes: [HTTPREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.resSetHeader": { argTypes: [HTTPRES_T, STRING, STRING], result: VOID },
-    "http.resWriteHead": { argTypes: [HTTPRES_T, F64], result: VOID },
-    "http.resWriteHeadN": { argTypes: [HTTPRES_T, F64, arrayOf(STRING), arrayOf(STRING)], result: VOID },
-    "http.resWriteContinue": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resWriteProcessing": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resWriteEarlyHints": { argTypes: [HTTPRES_T, arrayOf(STRING)], result: VOID },
-    "http.resWrite": { argTypes: [HTTPRES_T, STRING], result: VOID },
-    "http.resWriteBytes": { argTypes: [HTTPRES_T, BYTES_U8], result: VOID },
-    "http.resEnd": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resEndStr": { argTypes: [HTTPRES_T, STRING], result: VOID },
-    "http.resEndBytes": { argTypes: [HTTPRES_T, BYTES_U8], result: VOID },
-    "http.resWriteDyn": { argTypes: [HTTPRES_T, DYN], result: VOID },
-    "http.resEndDyn": { argTypes: [HTTPRES_T, DYN], result: VOID },
-    "http.resHeadersSent": { argTypes: [HTTPRES_T], result: BOOL },
-    "http.resWritableEnded": { argTypes: [HTTPRES_T], result: BOOL },
-    "http.resFlushHeaders": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resAddTrailers": { argTypes: [HTTPRES_T, arrayOf(STRING)], result: VOID },
-    "http.resCork": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resUncork": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resWritableCorked": { argTypes: [HTTPRES_T], result: F64 },
-    // The member follow-ups: reqStatusCode's `number | undefined` and
-    // sockRemoteAddress's `string | undefined` results are shape-checked in
-    // the special cases below (like reqHeader/columns).
-    "http.reqStatusCode": { argTypes: [HTTPREQ_T], result: VOID },
-    // reqStatusMessage's `string | undefined` is program-interned like
-    // reqHeader's (the VOID here is the envGet sentinel).
-    "http.reqStatusMessage": { argTypes: [HTTPREQ_T], result: VOID },
-    "http.reqRawHeaders": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
-    "http.reqHeaderPairs": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
-    "http.reqRawTrailers": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
-    "http.reqTrailerPairs": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
-    "net.sockDestroyed": { argTypes: [NETSOCKET_T], result: BOOL },
-    "net.sockWritable": { argTypes: [NETSOCKET_T], result: BOOL },
-    // The 'upgrade' registrations: the callback shapes are program-typed
-    // ((req, socket, head) and shorter prefixes — the libCall case checks).
-    "http.serverOnUpgrade": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "http.serverOnConnect": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "http.clientOnUpgrade": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
-    "http.reqSocket": { argTypes: [HTTPREQ_T], result: NETSOCKET_T },
-    // reqH2Stream's program-interned Http2Stream | undefined result is
-    // checked in the special libCall cases below.
-    "http.reqH2Stream": { argTypes: [HTTPREQ_T], result: VOID },
-    "http.reqH2StreamOrThrow": { argTypes: [HTTPREQ_T, STRING], result: HTTP2STREAM_T },
-    "http.reqPipeRes": { argTypes: [HTTPREQ_T, HTTPRES_T], result: VOID },
-    "http.reqPipeClient": { argTypes: [HTTPREQ_T, HTTPCLIENTREQ_T], result: VOID },
-    "http.reqPipeSock": { argTypes: [HTTPREQ_T, NETSOCKET_T], result: VOID },
-    "http.reqResume": { argTypes: [HTTPREQ_T], result: VOID },
-    "http.reqDestroy": { argTypes: [HTTPREQ_T], result: VOID },
-    "http.reqOnError": { argTypes: [HTTPREQ_T, null, BOOL], result: VOID },
-    "http.reqOnClose": { argTypes: [HTTPREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.reqOnAborted": { argTypes: [HTTPREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.reqHttpVersion": { argTypes: [HTTPREQ_T], result: STRING },
-    "http.reqHttpVersionMajor": { argTypes: [HTTPREQ_T], result: F64 },
-    "http.reqHttpVersionMinor": { argTypes: [HTTPREQ_T], result: F64 },
-    "http.reqAborted": { argTypes: [HTTPREQ_T], result: BOOL },
-    "http.reqComplete": { argTypes: [HTTPREQ_T], result: BOOL },
-    "http.resDestroy": { argTypes: [HTTPRES_T], result: VOID },
-    "http.resOnClose": { argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.resWriteHeadPairs": { argTypes: [HTTPRES_T, F64, arrayOf(STRING)], result: VOID },
-    "http.resWriteHeadDyn": { argTypes: [HTTPRES_T, F64, DYN], result: VOID },
-    "net.sockSetTimeout": { argTypes: [NETSOCKET_T, F64], result: VOID },
-    "net.sockSetEncoding": { argTypes: [NETSOCKET_T, STRING], result: VOID },
-    "http.reqSetEncoding": { argTypes: [HTTPREQ_T, STRING], result: VOID },
-    "net.sockOnTimeout": { argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "net.sockRemoteAddress": { argTypes: [NETSOCKET_T], result: VOID },
-    "net.sockEncrypted": { argTypes: [NETSOCKET_T], result: VOID },
-    // node:http, the client slice. The response callback shapes are
-    // program-dependent (checked below); header pairs arrive flat.
-    "http.request": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL], result: HTTPCLIENTREQ_T },
-    "http.requestCb": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, null], result: HTTPCLIENTREQ_T },
-    "http.agentNew": { argTypes: [BOOL, BOOL, F64, F64, F64, F64, F64], result: DYN },
-    "http.requestAgent": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, DYN], result: HTTPCLIENTREQ_T },
-    "http.requestAgentCb": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, DYN, null], result: HTTPCLIENTREQ_T },
-    "http.requestUrl": { argTypes: [STRING, STRING, BOOL], result: HTTPCLIENTREQ_T },
-    "http.requestUrlCb": { argTypes: [STRING, STRING, BOOL, null], result: HTTPCLIENTREQ_T },
-    "net.sockOnReadable": { argTypes: [NETSOCKET_T, null, BOOL], result: VOID },
-    // sockRead's result is the interned `Buffer | null` union — checked
-    // specially below (the reqHeader/envGet pattern; VOID here is a
-    // placeholder the special case overrides).
-    "net.sockRead": { argTypes: [NETSOCKET_T, F64], result: VOID },
-    "net.sockUnshift": { argTypes: [NETSOCKET_T, BYTES_U8], result: VOID },
-    "net.sockPause": { argTypes: [NETSOCKET_T], result: NETSOCKET_T },
-    "net.sockResume": { argTypes: [NETSOCKET_T], result: NETSOCKET_T },
-    "net.sockSetNoDelay": { argTypes: [NETSOCKET_T, BOOL], result: NETSOCKET_T },
-    "net.sockDestroySoon": { argTypes: [NETSOCKET_T], result: VOID },
-    "net.sockBytesWritten": { argTypes: [NETSOCKET_T], result: F64 },
-    "net.sockReadable": { argTypes: [NETSOCKET_T], result: BOOL },
-    "net.sockOnFinish": { argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "net.serverEmitConnection": { argTypes: [NETSERVER_T, NETSOCKET_T], result: VOID },
-    // tls/https: cert/key/ca PEM arguments are strings OR Buffers (null =
-    // both accepted; the emitter passes data+len either way).
-    "tls.createServer": { argTypes: [null, null], result: NETSERVER_T },
-    "tls.createServerCb": { argTypes: [null, null, null], result: NETSERVER_T },
-    // The runtime options records (divergence 66's stance): a dyn options
-    // value whose members read at runtime; pemDyn extracts a runtime-valued
-    // cert/key member (arg 1 is the precomposed fence label).
-    "tls.pemDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
-    "tls.createServerDyn": { argTypes: [DYN], result: NETSERVER_T },
-    "tls.createServerDynCb": { argTypes: [DYN, null], result: NETSERVER_T },
-    "https.createServerDyn": { argTypes: [DYN], result: NETSERVER_T },
-    "https.createServerDynCb": { argTypes: [DYN, null], result: NETSERVER_T },
-    "http2.createSecureServerReq": { argTypes: [null, null, null, BOOL], result: NETSERVER_T },
-    "http2.createSecureServerH2Req": { argTypes: [null, null, null, BOOL], result: NETSERVER_T },
-    "http2.createSecureServerDyn": { argTypes: [DYN], result: NETSERVER_T },
-    "http2.createSecureServerDynCb": { argTypes: [DYN, null], result: NETSERVER_T },
-    // tls.connect(port, host, opts[, cb]) — port -1 / host "" read the
-    // options record; the callback fires post-handshake (secureConnect).
-    "tls.connect": { argTypes: [F64, STRING, DYN], result: NETSOCKET_T },
-    "tls.connectCb": { argTypes: [F64, STRING, DYN, null], result: NETSOCKET_T },
-    // The TLSSocket member surface (authError's `string | null` union is
-    // shape-checked in the special cases below — the reqHeader pattern).
-    "tls.sockAuthorized": { argTypes: [NETSOCKET_T], result: BOOL },
-    "tls.sockAuthError": { argTypes: [NETSOCKET_T], result: VOID },
-    "tls.sockOnSecureConnect": { argTypes: [NETSOCKET_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "tls.sockOnSession": { argTypes: [NETSOCKET_T, null, BOOL], result: VOID },
-    // createSecureContext({ cert, key }) mints the opaque SNI-answer handle.
-    "tls.createSecureContext": { argTypes: [null, null], result: SECURECTX_T },
-    "tls.createSecureContextDyn": { argTypes: [DYN], result: SECURECTX_T },
-    "tls.caCertsChk": { argTypes: [DYN, STRING], result: VOID },
-    // The CA-store introspection unit (scr_tls_ca.c): per-type cached PEM
-    // string arrays and the default-set replacement.
-    "tlsca.get": { argTypes: [STRING], result: arrayOf(STRING) },
-    "tlsca.root": { argTypes: [], result: arrayOf(STRING) },
-    "tlsca.set": { argTypes: [arrayOf(STRING)], result: VOID },
-    "https.createServer": { argTypes: [null, null, null], result: NETSERVER_T },
-    // http2's allowHTTP1 compatibility server (divergence 57): cert/key
-    // like tls.createServer; the 'request' handler arrives separately via
-    // http.serverOnRequest (shape checked in the libCall case, like
-    // http.createServer's). sessionError callback shape is checked below.
-    "http2.createSecureServer": { argTypes: [null, null, BOOL], result: NETSERVER_T },
-    // The SNI-callback form: arg 2 is the JS SNICallback closure — a
-    // `(servername, cb) => void` func, or its `| undefined` union from the
-    // conditional-spread spelling (the libCall case checks the shape).
-    "http2.createSecureServerSni": { argTypes: [null, null, null, BOOL], result: NETSERVER_T },
-    // The ALPN=h2 server (createSecureServer without allowHTTP1): the real
-    // h2 session machinery behind the TLS handshake.
-    "http2.createSecureServerH2": { argTypes: [null, null, BOOL], result: NETSERVER_T },
-    "http.serverOnRequest": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "http2.serverOnSessionError": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "http2.streamNoop": { argTypes: [], result: VOID },
-    "http2.streamUndefCall": { argTypes: [STRING], result: VOID },
-    // The REAL h2c surface (scr_http2.c). Callback slots are null (the
-    // emitter picks the thunk); pairs slots are string arrays; the
-    // endStream tri-state and event flags ride as f64.
-    "http2.createServer": { argTypes: [], result: NETSERVER_T },
-    "http2.createServerReq": { argTypes: [null], result: NETSERVER_T },
-    "http2.serverOnStream": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    "http2.serverOnSession": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
-    // connect(authority, reject, ca[, cb]): the TLS client knobs an https
-    // authority reads (inert on http ones, exactly Node); ca is a PEM
-    // string/Buffer ("" = the system anchors).
-    "http2.connect": { argTypes: [STRING, BOOL, null], result: HTTP2SESSION_T },
-    "http2.connectCb": { argTypes: [STRING, BOOL, null, null], result: HTTP2SESSION_T },
-    "http2.sessionRequest": { argTypes: [HTTP2SESSION_T, arrayOf(STRING), F64], result: HTTP2STREAM_T },
-    "http2.sessionClose": { argTypes: [HTTP2SESSION_T], result: VOID },
-    "http2.sessionCloseCb": { argTypes: [HTTP2SESSION_T, null], result: VOID },
-    "http2.sessionDestroy": { argTypes: [HTTP2SESSION_T], result: VOID },
-    "http2.sessionOnClose": { argTypes: [HTTP2SESSION_T, null, BOOL], result: VOID },
-    "http2.sessionOnError": { argTypes: [HTTP2SESSION_T, null, BOOL], result: VOID },
-    "http2.sessionOnConnect": { argTypes: [HTTP2SESSION_T, null, BOOL], result: VOID },
-    "http2.sessionOnStream": { argTypes: [HTTP2SESSION_T, null, BOOL], result: VOID },
-    "http2.sessionOnGoaway": { argTypes: [HTTP2SESSION_T, null, BOOL], result: VOID },
-    "http2.sessionClosed": { argTypes: [HTTP2SESSION_T], result: BOOL },
-    "http2.sessionDestroyed": { argTypes: [HTTP2SESSION_T], result: BOOL },
-    "http2.sessionEncrypted": { argTypes: [HTTP2SESSION_T], result: BOOL },
-    "http2.sessionType": { argTypes: [HTTP2SESSION_T], result: F64 },
-    "http2.sessionAlpn": { argTypes: [HTTP2SESSION_T], result: STRING },
-    "http2.sessionSocket": { argTypes: [HTTP2SESSION_T], result: NETSOCKET_T },
-    "http2.streamRespond": { argTypes: [HTTP2STREAM_T, arrayOf(STRING), BOOL], result: VOID },
-    "http2.streamWrite": { argTypes: [HTTP2STREAM_T, STRING], result: VOID },
-    "http2.streamWriteBytes": { argTypes: [HTTP2STREAM_T, BYTES_U8], result: VOID },
-    "http2.streamEnd": { argTypes: [HTTP2STREAM_T], result: VOID },
-    "http2.streamEndStr": { argTypes: [HTTP2STREAM_T, STRING], result: VOID },
-    "http2.streamEndBytes": { argTypes: [HTTP2STREAM_T, BYTES_U8], result: VOID },
-    "http2.streamClose": { argTypes: [HTTP2STREAM_T, F64], result: VOID },
-    "http2.streamCloseCb": { argTypes: [HTTP2STREAM_T, F64, null], result: VOID },
-    "http2.streamDestroy": { argTypes: [HTTP2STREAM_T], result: VOID },
-    "http2.sessionSettings0": { argTypes: [HTTP2SESSION_T], result: VOID },
-    "http2.sessionSettings": { argTypes: [HTTP2SESSION_T, DYN], result: VOID },
-    "http2.sessionSettingsDynCb": { argTypes: [HTTP2SESSION_T, DYN, DYN], result: VOID },
-    "http2.sessionSettingsCb0": { argTypes: [HTTP2SESSION_T, DYN, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "http2.sessionOnSettingsDyn": { argTypes: [HTTP2SESSION_T, DYN, BOOL, BOOL], result: VOID },
-    "http2.sessionOnSettings0": { argTypes: [HTTP2SESSION_T, { kind: "func", params: [], ret: VOID }, BOOL, BOOL], result: VOID },
-    "http2.sessionSettingsGet": { argTypes: [HTTP2SESSION_T, BOOL], result: DYN },
-    "http2.sessionPendingSettingsAck": { argTypes: [HTTP2SESSION_T], result: BOOL },
-    "http2.getDefaultSettings": { argTypes: [], result: DYN },
-    "http2.streamSetEncoding": { argTypes: [HTTP2STREAM_T, STRING], result: VOID },
-    "http2.streamSetEncodingRet": { argTypes: [HTTP2STREAM_T, STRING], result: HTTP2STREAM_T },
-    "http2.streamResume": { argTypes: [HTTP2STREAM_T], result: VOID },
-    "http2.streamPause": { argTypes: [HTTP2STREAM_T], result: VOID },
-    "http2.streamOnData": { argTypes: [HTTP2STREAM_T, null, BOOL], result: VOID },
-    "http2.streamOnEnd": { argTypes: [HTTP2STREAM_T, null, BOOL], result: VOID },
-    "http2.streamOnClose": { argTypes: [HTTP2STREAM_T, null, BOOL], result: VOID },
-    "http2.streamOnAborted": { argTypes: [HTTP2STREAM_T, null, BOOL], result: VOID },
-    "http2.streamOnError": { argTypes: [HTTP2STREAM_T, null, BOOL], result: VOID },
-    "http2.streamOnResponse": { argTypes: [HTTP2STREAM_T, null, BOOL], result: VOID },
-    "http2.streamId": { argTypes: [HTTP2STREAM_T], result: F64 },
-    "http2.streamRstCode": { argTypes: [HTTP2STREAM_T], result: F64 },
-    "http2.streamDestroyed": { argTypes: [HTTP2STREAM_T], result: BOOL },
-    "http2.streamClosed": { argTypes: [HTTP2STREAM_T], result: BOOL },
-    "http2.streamAborted": { argTypes: [HTTP2STREAM_T], result: BOOL },
-    "http2.streamPending": { argTypes: [HTTP2STREAM_T], result: BOOL },
-    "http2.streamSession": { argTypes: [HTTP2STREAM_T], result: HTTP2SESSION_T },
-    // The createConnection forms: arg 0 is the dialer closure (() =>
-    // Socket — the libCall case checks), then path/method/timeout/headers/
-    // autoEnd like http.request.
-    "http.requestConn": { argTypes: [null, STRING, STRING, F64, arrayOf(STRING), BOOL], result: HTTPCLIENTREQ_T },
-    "http.requestConnCb": { argTypes: [null, STRING, STRING, F64, arrayOf(STRING), BOOL, null], result: HTTPCLIENTREQ_T },
-    "https.request": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null], result: HTTPCLIENTREQ_T },
-    "https.requestCb": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null, null], result: HTTPCLIENTREQ_T },
-    "https.requestUrl": { argTypes: [STRING, STRING, BOOL], result: HTTPCLIENTREQ_T },
-    "https.requestUrlCb": { argTypes: [STRING, STRING, BOOL, null], result: HTTPCLIENTREQ_T },
-    "https.requestAgent": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null, DYN], result: HTTPCLIENTREQ_T },
-    "https.requestAgentCb": { argTypes: [STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null, DYN, null], result: HTTPCLIENTREQ_T },
-    // The requestFn binding's runtime-secure rows: https.request's shape
-    // with the leading `secure` bool.
-    "https.requestFn": { argTypes: [BOOL, STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null], result: HTTPCLIENTREQ_T },
-    "https.requestFnCb": { argTypes: [BOOL, STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null, null], result: HTTPCLIENTREQ_T },
-    "http.clientWrite": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
-    "http.clientSetHeader": { argTypes: [HTTPCLIENTREQ_T, STRING, STRING], result: VOID },
-    "http.clientGetHeader": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
-    "http.clientHasHeader": { argTypes: [HTTPCLIENTREQ_T, STRING], result: BOOL },
-    "http.clientRemoveHeader": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
-    "http.clientGetHeaderNames": { argTypes: [HTTPCLIENTREQ_T], result: arrayOf(STRING) },
-    "http.clientGetRawHeaderNames": { argTypes: [HTTPCLIENTREQ_T], result: arrayOf(STRING) },
-    "http.clientGetHeaders": { argTypes: [HTTPCLIENTREQ_T], result: DYN },
-    "http.clientWriteBytes": { argTypes: [HTTPCLIENTREQ_T, BYTES_U8], result: VOID },
-    "http.clientEnd": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
-    "http.clientEndStr": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
-    "http.clientEndBytes": { argTypes: [HTTPCLIENTREQ_T, BYTES_U8], result: VOID },
-    "http.clientWriteDyn": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
-    "http.clientEndDyn": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
-    "http.clientFlushHeaders": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
-    "http.clientAddTrailers": { argTypes: [HTTPCLIENTREQ_T, arrayOf(STRING)], result: VOID },
-    "http.clientCork": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
-    "http.clientUncork": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
-    "http.clientWritableCorked": { argTypes: [HTTPCLIENTREQ_T], result: F64 },
-    "http.clientMethod": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
-    "http.clientPath": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
-    "http.clientHost": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
-    "http.clientProtocol": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
-    "http.clientHeadersSent": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
-    "http.clientWritableEnded": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
-    "http.clientWritableFinished": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
-    "http.clientSocket": { argTypes: [HTTPCLIENTREQ_T], result: NETSOCKET_T },
-    "http.clientReusedSocket": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
-    "http.clientSetNoDelay": { argTypes: [HTTPCLIENTREQ_T, BOOL], result: VOID },
-    "http.clientSetSocketKeepAlive": { argTypes: [HTTPCLIENTREQ_T, BOOL, F64], result: VOID },
-    "http.clientSetTimeout": { argTypes: [HTTPCLIENTREQ_T, F64], result: VOID },
-    "http.clientSetTimeoutCb": { argTypes: [HTTPCLIENTREQ_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "http.statusCodes": { argTypes: [], result: DYN },
-    "http.methods": { argTypes: [], result: arrayOf(STRING) },
-    "http.reqSetTimeout": { argTypes: [HTTPREQ_T, F64], result: VOID },
-    "http.reqSetTimeoutCb": { argTypes: [HTTPREQ_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
-    "http.clientDestroy": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
-    "http.clientAbort": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
-    "http.clientAborted": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
-    "http.clientDestroyed": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
-    "http.clientOnResponse": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
-    "http.clientOnSocket": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
-    "http.clientOnFinish": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.clientOnError": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
-    "http.clientOnTimeout": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.clientOnClose": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "http.clientOnAbort": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
-    "cp.execSync": {
-        argTypes: [STRING, arrayOf(STRING), BOOL, STRING, BOOL, STRING, BOOL, arrayOf(STRING), F64, F64, F64],
-        result: STRING,
-    },
-    "cp.execCapture": {
-        argTypes: [STRING, arrayOf(STRING), STRING, BOOL, arrayOf(STRING), F64],
-        result: SPAWNRES_T,
-    },
-    "cp.spawn": { argTypes: [STRING, arrayOf(STRING)], result: CHILD_T },
-    "process.forkTarget": { argTypes: [F64], result: F64 },
-    "cp.fork": {
-        argTypes: [F64, arrayOf(STRING), F64, F64, F64, BOOL, arrayOf(STRING), STRING],
-        result: CHILD_T,
-    },
-    "child.connected": { argTypes: [CHILD_T], result: BOOL },
-    "child.send": { argTypes: [CHILD_T, STRING], result: BOOL },
-    "child.sendCb": { argTypes: [CHILD_T, STRING, null], result: BOOL },
-    "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 },
-    "process.disconnect": { argTypes: [], result: VOID },
-    "process.onMessage": { argTypes: [null, BOOL], result: VOID },
-    "process.onDisconnect": { argTypes: [null, BOOL], result: VOID },
-    "cp.execFile": { argTypes: [STRING, arrayOf(STRING), null], result: CHILD_T },
-    // spawn's options form: per-slot stdio modes (0 ignore / 1 inherit /
-    // 2 fd) with the out/err fds for mode 2, detached, env replacement
-    // pairs, cwd ("" = inherit).
-    "cp.spawnOpts": {
-        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.
-    "child.onExit": { argTypes: [CHILD_T, null], result: VOID },
-    "child.onClose": { argTypes: [CHILD_T, null], result: VOID },
-    "child.onError": { argTypes: [CHILD_T, null], result: VOID },
-    // Like process.envGet, spawnRes.status's result type is program-dependent
-    // (the interned `number | null` union) — the libCall case checks the arms.
-    "spawnRes.status": { argTypes: [SPAWNRES_T], result: VOID },
-    // spawnRes.error's result is the interned `Error | undefined` union —
-    // the libCall case checks the arms, the spawnRes.status pattern.
-    "spawnRes.error": { argTypes: [SPAWNRES_T], result: VOID },
-    // spawnRes.signal's result is the interned `string | null` union —
-    // same pattern.
-    "spawnRes.signal": { argTypes: [SPAWNRES_T], result: VOID },
-    // The ChildProcess lifecycle members: pid/exitCode are program-dependent
-    // unions (`number | undefined` / `number | null` — the libCall case
-    // checks the arms, the spawnRes.status pattern).
-    "child.pid": { argTypes: [CHILD_T], result: VOID },
-    "child.exitCode": { argTypes: [CHILD_T], result: VOID },
-    // The close-override pair: the bound close's result func type and the
-    // override's func argument are program-dependent (the callback union's
-    // tags) — the slots pin the server receiver; the libCall case checks
-    // the bound value's shape.
-    "net.serverCloseBind": { argTypes: [NETSERVER_T], result: VOID },
-    "net.serverSetCloseOverride": { argTypes: [NETSERVER_T, null], result: VOID },
-    // The piped-output stream reads: `Readable | null` unions (the libCall
-    // case checks the arms — the child.pid pattern with a ref arm).
-    "child.stdout": { argTypes: [CHILD_T], result: VOID },
-    "child.stderr": { argTypes: [CHILD_T], result: VOID },
-    "child.stdin": { argTypes: [CHILD_T], result: VOID },
-    // Listener registrations: callback func shapes are program-dependent
-    // (zero-param / Buffer / Buffer-armed union) — the slots pin arity,
-    // the stream receiver, and the once-flag.
-    "stream.onData": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
-    "stream.onDataStr": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
-    "stream.onEnd": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
-    "stream.childSetEncoding": { argTypes: [CHILDSTREAM_T, STRING], result: CHILDSTREAM_T },
-    "writer.writeString": { argTypes: [CHILDWRITER_T, STRING], result: BOOL },
-    "writer.writeBytes": { argTypes: [CHILDWRITER_T, BYTES_U8], result: BOOL },
-    "writer.end": { argTypes: [CHILDWRITER_T], result: VOID },
-    "writer.destroy": { argTypes: [CHILDWRITER_T], result: VOID },
-    "writer.writable": { argTypes: [CHILDWRITER_T], result: BOOL },
-    "writer.onDrain": { argTypes: [CHILDWRITER_T, null, BOOL], result: VOID },
-    "writer.onFinish": { argTypes: [CHILDWRITER_T, null, BOOL], result: VOID },
-    "writer.onError": { argTypes: [CHILDWRITER_T, null, BOOL], result: VOID },
-    "procStream.write": { argTypes: [PROCSTREAM_T, STRING], result: BOOL },
-    "child.killed": { argTypes: [CHILD_T], result: BOOL },
-    "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 },
-    "crypto.randomBytesToString": { argTypes: [F64, STRING], result: STRING },
-    "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 },
-    "crypto.hashUpdateStr": { argTypes: [CRYPTOHASH_T, STRING], result: CRYPTOHASH_T },
-    "crypto.hashUpdateBytes": { argTypes: [CRYPTOHASH_T, BYTES_U8], result: CRYPTOHASH_T },
-    "crypto.hmacUpdateStr": { argTypes: [CRYPTOHMAC_T, STRING], result: CRYPTOHMAC_T },
-    "crypto.hmacUpdateBytes": { argTypes: [CRYPTOHMAC_T, BYTES_U8], result: CRYPTOHMAC_T },
-    "crypto.hashCopy": { argTypes: [CRYPTOHASH_T], result: CRYPTOHASH_T },
-    "crypto.hashDigestString": { argTypes: [CRYPTOHASH_T, STRING], result: STRING },
-    "crypto.hashDigestBuffer": { argTypes: [CRYPTOHASH_T], result: BYTES_U8 },
-    "crypto.hmacDigestString": { argTypes: [CRYPTOHMAC_T, STRING], result: STRING },
-    "crypto.hmacDigestBuffer": { argTypes: [CRYPTOHMAC_T], result: BYTES_U8 },
-    "crypto.timingSafeEqual": { argTypes: [BYTES_U8, BYTES_U8], result: BOOL },
-    "crypto.randomFill": { argTypes: [BYTES_U8, F64, F64], result: BYTES_U8 },
-    "crypto.randomFillRest": { argTypes: [BYTES_U8, F64], result: BYTES_U8 },
-    "crypto.randomInt": { argTypes: [F64, F64], result: F64 },
-    "crypto.pbkdf2": { argTypes: [BYTES_U8, BYTES_U8, F64, F64, STRING], result: BYTES_U8 },
-    "crypto.randomBytesCb": { argTypes: [F64, null], result: VOID },
-    "crypto.pbkdf2Cb": { argTypes: [BYTES_U8, BYTES_U8, F64, F64, STRING, null], result: VOID },
-    "crypto.hkdf": { argTypes: [STRING, BYTES_U8, BYTES_U8, BYTES_U8, F64], result: DYN },
-    "crypto.hkdfCb": { argTypes: [STRING, BYTES_U8, BYTES_U8, BYTES_U8, F64, null], result: VOID },
-    "crypto.scrypt": { argTypes: [BYTES_U8, BYTES_U8, F64, DYN], result: BYTES_U8 },
-    "crypto.scryptCb": { argTypes: [BYTES_U8, BYTES_U8, F64, DYN, null], result: VOID },
-    // 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 },
-    // The checked-dynamic compare/equals validators (Node's argument
-    // ladders over dyn-boxed invalid-input probes).
-    "buffer.compareChk": { argTypes: [DYN, DYN], result: F64 },
-    "bytes.equalsChk": { argTypes: [BYTES_U8, DYN], result: BOOL },
-    "bytes.compareChk": { argTypes: [BYTES_U8, DYN, DYN, DYN, DYN, DYN], result: F64 },
-    "buffer.newStringFail": { argTypes: [DYN], result: BYTES_U8 },
-    "fs.toUnixTimestamp": { argTypes: [DYN], result: F64 },
-    "fs.existsChk": { argTypes: [DYN, DYN], result: DYN },
-    "fs.mkdtempChk": { argTypes: [DYN, DYN, STRING], result: VOID },
-    "fs.mkdtempSyncChk": { argTypes: [DYN, DYN, STRING], result: STRING },
-    "fs.readFileChk": { argTypes: [DYN, DYN, DYN, STRING], result: VOID },
-    "fs.opendirChk": { argTypes: [DYN, DYN, STRING], result: VOID },
-    "fs.watchFileChk": { argTypes: [DYN, DYN, STRING], result: VOID },
-    "fs.lchmodChk": { argTypes: [DYN, DYN, DYN, STRING], result: VOID },
-    "fs.lchmodSyncChk": { argTypes: [DYN, DYN], result: DYN },
-    "fsp.lchmodChk": { argTypes: [DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "fs.readChk": { argTypes: [DYN, DYN, DYN, DYN, DYN, STRING], result: VOID },
-    "fs.streamOptsChk": { argTypes: [DYN, DYN, STRING], result: VOID },
-    "error.argTypeThrow": { argTypes: [STRING, STRING, DYN], result: VOID },
-    "error.propTypeThrow": { argTypes: [STRING, STRING, DYN], result: VOID },
-    "emitter.setMaxChk": { argTypes: [null, DYN], result: VOID },
-    "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 },
-    "zlib.unzipSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
-    "zlib.deflateCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.inflateCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.deflateRawCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.inflateRawCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.gzipCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.gunzipCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.unzipCb": { argTypes: [BYTES_U8, null], result: VOID },
-    "zlib.crc32": { argTypes: [BYTES_U8, F64], result: F64 },
-    "process.stdoutWriteBytes": { argTypes: [BYTES_U8, STRING], result: BOOL },
-    "process.stderrWriteBytes": { argTypes: [BYTES_U8, STRING], result: BOOL },
-    // Completion callback is program-dependent: zero params, checked-dynamic,
-    // or an optional Error | null slot (same success shape as fs.rename).
-    "process.stdoutWriteBytesCb": { argTypes: [BYTES_U8, STRING, null], result: BOOL },
-    "process.stderrWriteBytesCb": { argTypes: [BYTES_U8, STRING, null], result: BOOL },
-    "fsp.readFile": { argTypes: [STRING, STRING], result: { kind: "promise", inner: STRING } },
-    "fsp.writeFile": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.writeFileMode": { argTypes: [STRING, STRING, F64], result: { kind: "promise", inner: VOID } },
-    "fsp.mkdir": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.mkdirMode": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
-    "fsp.mkdirRecursive": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.mkdirRecursiveMode": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
-    "fsp.unlink": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.chmod": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
-    "fsp.link": { argTypes: [DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "fsp.symlink": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "fsp.readlink": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
-    "fsp.statfs": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
-    "fsp.readlinkStr": { argTypes: [DYN, DYN], result: { kind: "promise", inner: STRING } },
-    "fsp.readlinkBuffer": { argTypes: [DYN, DYN], result: { kind: "promise", inner: BYTES_U8 } },
-    "fsp.utimes": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "fsp.lutimes": { argTypes: [DYN, DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "fsp.rename": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.readdir": { argTypes: [STRING], result: { kind: "promise", inner: arrayOf(STRING) } },
-    // Result is promise<call-site Dirent record array>; the libCall case
-    // validates the program-dependent record shape below.
-    "fsp.readdirTypes": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.rm": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
-    "fsp.stat": { argTypes: [STRING], result: { kind: "promise", inner: STATS_T } },
-    "fsp.realpath": { argTypes: [STRING], result: { kind: "promise", inner: STRING } },
-    "fsp.lstat": { argTypes: [STRING], result: { kind: "promise", inner: STATS_T } },
-    "fsp.open": { argTypes: [STRING, STRING, F64], result: { kind: "promise", inner: FILEHANDLE_T } },
-    "fileHandle.fd": { argTypes: [FILEHANDLE_T], result: F64 },
-    "fileHandle.close": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: VOID } },
-    "fileHandle.sync": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: VOID } },
-    "fileHandle.datasync": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: VOID } },
-    "fileHandle.truncate": { argTypes: [FILEHANDLE_T, F64], result: { kind: "promise", inner: VOID } },
-    "fileHandle.chmod": { argTypes: [FILEHANDLE_T, F64], result: { kind: "promise", inner: VOID } },
-    "fileHandle.utimes": { argTypes: [FILEHANDLE_T, DYN, DYN], result: { kind: "promise", inner: VOID } },
-    "fileHandle.readv": { argTypes: [FILEHANDLE_T, arrayOf(BYTES_U8), F64], result: { kind: "promise", inner: VOID } },
-    "fileHandle.writev": { argTypes: [FILEHANDLE_T, arrayOf(BYTES_U8), F64], result: { kind: "promise", inner: VOID } },
-    // read/write carry call-site result record shapes; the validator checks
-    // those below, so promise<void> is only a table sentinel.
-    "fileHandle.read": { argTypes: [FILEHANDLE_T, BYTES_U8, F64, F64, F64, BOOL], result: { kind: "promise", inner: VOID } },
-    "fileHandle.writeBytes": { argTypes: [FILEHANDLE_T, BYTES_U8, F64, F64, F64, BOOL], result: { kind: "promise", inner: VOID } },
-    "fileHandle.writeStr": { argTypes: [FILEHANDLE_T, STRING, F64, STRING], result: { kind: "promise", inner: VOID } },
-    "fileHandle.readFile": { argTypes: [FILEHANDLE_T, STRING], result: { kind: "promise", inner: STRING } },
-    "fileHandle.readFileBytes": { argTypes: [FILEHANDLE_T, STRING], result: { kind: "promise", inner: BYTES_U8 } },
-    "fileHandle.writeFile": { argTypes: [FILEHANDLE_T, STRING, STRING], result: { kind: "promise", inner: VOID } },
-    "fileHandle.writeFileBytes": { argTypes: [FILEHANDLE_T, BYTES_U8, STRING], result: { kind: "promise", inner: VOID } },
-    "fileHandle.stat": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: STATS_T } },
-    "process.argv": { argTypes: [], result: arrayOf(STRING) },
-    "process.platform": { argTypes: [], result: STRING },
-    // The one libCall whose result type is program-dependent (union ids are
-    // per-module): the `result` here is a placeholder — the libCall case
-    // checks the union's ARMS ([string, undefinedT] in canonical order)
-    // against the module's registry instead.
-    "process.envGet": { argTypes: [STRING], result: VOID },
-    "process.envSet": { argTypes: [STRING, STRING], result: VOID },
-    "process.envUnset": { argTypes: [STRING], result: VOID },
-    "process.envPairs": { argTypes: [], result: arrayOf(STRING) },
-    "process.exit": { argTypes: [F64], result: VOID },
-    "process.setExitCode": { argTypes: [F64], result: VOID },
-    "process.currentExitCode": { argTypes: [], result: F64 },
-    "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 },
-    // DOMException: construction takes the two dyn args (WebIDL's
-    // resolution runs in the runtime); the %DOMException result is a
-    // program-dependent object type, checked in the libCall case. The
-    // read surface takes the %DOMException receiver (a null slot — the
-    // libCall case checks the class name).
-    "error.newDom": { argTypes: [DYN, DYN], result: VOID },
-    "error.domCode": { argTypes: [null], result: F64 },
-    "error.domHasCause": { argTypes: [null], result: BOOL },
-    "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.reflectGet": { argTypes: [DYN, DYN, DYN], result: DYN },
-    "dyn.reflectSet": { argTypes: [DYN, DYN, DYN, DYN], result: BOOL },
-    "dyn.reflectDefine": { argTypes: [DYN, DYN, DYN], result: BOOL },
-    "dyn.abstractEq": { argTypes: [DYN, DYN], result: BOOL },
-    "dyn.assignAll": { argTypes: [DYN, DYN], result: DYN },
-    "dyn.objCreateNullProto": { argTypes: [], result: DYN },
-    "dyn.arrayPrototype": { argTypes: [], result: DYN },
-    "dyn.arrayConstructor": { 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.definePrototypeProps": { argTypes: [DYN, DYN, DYN], result: DYN },
-    "dyn.bagGet": { argTypes: [DYN, STRING, DYN], result: DYN },
-    "dyn.bagSet": { argTypes: [DYN, STRING, DYN, DYN], result: VOID },
-    "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
-    // case. emitter.emit is the one VARIADIC libCall: args beyond
-    // (recv, name) are the event's frontend-unified tuple, any borrowable
-    // kind — the count check admits a longer list for it alone.
-    "emitter.new": { argTypes: [], result: VOID },
-    "emitter.ctor": { argTypes: [null], result: VOID },
-    "emitter.on": { argTypes: [null, STRING, null, BOOL, BOOL], result: VOID },
-    "emitter.off": { argTypes: [null, STRING, null], result: VOID },
-    // The dyn-adapted registration family (JS-lane checked-dynamic
-    // listeners): checkListener has NO receiver (it validates the listener
-    // argument alone); onDyn carries (recv, name, cb dyn, adapter func,
-    // once, prepend), offDyn (recv, name, cb dyn).
-    "emitter.checkListener": { argTypes: [DYN], result: VOID },
-    "emitter.onDyn": { argTypes: [null, STRING, DYN, null, BOOL, BOOL], result: VOID },
-    "emitter.onFlex": { argTypes: [null, STRING, DYN, BOOL, BOOL], result: VOID },
-    "emitter.offDyn": { argTypes: [null, STRING, DYN], result: VOID },
-    "emitter.removeAll": { argTypes: [null, STRING, BOOL], result: VOID },
-    "emitter.emit": { argTypes: [null, STRING], result: BOOL },
-    "emitter.emitFlex": { argTypes: [null, STRING], result: BOOL },
-    "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 },
-    "emitter.onDataDyn": { argTypes: [null, STRING, DYN, null, BOOL, BOOL], result: VOID },
-    "emitter.emitData": { argTypes: [null, STRING, null], result: BOOL },
-    "emitter.setMax": { argTypes: [null, F64], result: VOID },
-    "emitter.getMax": { argTypes: [null], result: F64 },
-    "emitter.setDefaultMax": { argTypes: [F64], result: VOID },
-    "emitter.getDefaultMax": { argTypes: [], result: F64 },
-    // node:stream: receivers are stream-hierarchy objects and several
-    // results are program-dependent (the receiver's class, unions) — the
-    // libCall case owns those checks. The constructors and a few methods
-    // are VARIADIC (trailing option callbacks / the optional chunk+cb tail):
-    // argTypes here is the fixed prefix, VARIADIC_LIB_FNS admits the rest.
-    "readable.new": { argTypes: [F64, BOOL, BOOL, F64], result: VOID },
-    "writable.new": { argTypes: [F64, BOOL, BOOL, F64], result: VOID },
-    "duplex.new": { argTypes: [F64, F64, BOOL, BOOL, BOOL, BOOL, BOOL, F64], result: VOID },
-    "transform.new": { argTypes: [F64, F64, BOOL, BOOL, BOOL, BOOL, BOOL, F64], result: VOID },
-    "passthrough.new": { argTypes: [F64, F64, BOOL, BOOL, BOOL, BOOL, BOOL, F64], result: VOID },
-    // The subclass-initialization twins: the borrowed receiver leads, then
-    // the .new tail (variadic callbacks likewise).
-    // The dyn-options twins: newDyn takes the record, initDyn the borrowed
-    // receiver + record + fallback flags (trailing wrapper closures ride
-    // the variadic tail like the static forms).
-    "stream.setRead": { argTypes: [null, null], result: VOID },
-    "stream.setWrite": { argTypes: [null, null], result: VOID },
-    "stream.setFinal": { argTypes: [null, null], result: VOID },
-    "stream.setDestroy": { argTypes: [null, null], result: VOID },
-    "stream.setTransform": { argTypes: [null, null], result: VOID },
-    "stream.setFlush": { argTypes: [null, null], result: VOID },
-    "stream.finished": { argTypes: [null, null], result: VOID },
-    "stream.finishedDyn": { argTypes: [null, DYN], result: VOID },
-    "stream.pipeline": { argTypes: [F64], result: VOID },
-    "stream.pipelineDyn": { argTypes: [F64], result: VOID },
-    "sp.finished": { argTypes: [null], result: { kind: "promise", inner: VOID } },
-    "sp.pipeline": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
-    "sc.text": { argTypes: [null], result: { kind: "promise", inner: STRING } },
-    "sc.json": { argTypes: [null], result: { kind: "promise", inner: DYN } },
-    "sc.buffer": { argTypes: [null], result: { kind: "promise", inner: BYTES_U8 } },
-    "readable.newDyn": { argTypes: [DYN], result: VOID },
-    "writable.newDyn": { argTypes: [DYN], result: VOID },
-    "duplex.newDyn": { argTypes: [DYN], result: VOID },
-    "transform.newDyn": { argTypes: [DYN], result: VOID },
-    "passthrough.newDyn": { argTypes: [DYN], result: VOID },
-    "readable.initDyn": { argTypes: [null, DYN, F64], result: VOID },
-    "writable.initDyn": { argTypes: [null, DYN, F64], result: VOID },
-    "duplex.initDyn": { argTypes: [null, DYN, F64], result: VOID },
-    "transform.initDyn": { argTypes: [null, DYN, F64], result: VOID },
-    "passthrough.initDyn": { argTypes: [null, DYN, F64], result: VOID },
-    "readable.init": { argTypes: [null, F64, BOOL, BOOL, F64], result: VOID },
-    "writable.init": { argTypes: [null, F64, BOOL, BOOL, F64], result: VOID },
-    "duplex.init": { argTypes: [null, F64, F64, BOOL, BOOL, BOOL, BOOL, BOOL, F64], result: VOID },
-    "transform.init": { argTypes: [null, F64, F64, BOOL, BOOL, BOOL, BOOL, BOOL, F64], result: VOID },
-    "passthrough.init": { argTypes: [null, F64, F64, BOOL, BOOL, BOOL, BOOL, BOOL, F64], result: VOID },
-    "readable.push": { argTypes: [null, BYTES_U8], result: BOOL },
-    "readable.pushStr": { argTypes: [null, STRING], result: BOOL },
-    "readable.pushNull": { argTypes: [null], result: BOOL },
-    "readable.pushU": { argTypes: [null, null], result: BOOL },
-    "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 },
-    "readable.pushStrEnc": { argTypes: [null, STRING, STRING], result: BOOL },
-    "readable.pushEncoding": { argTypes: [null, STRING], result: VOID },
-    "readable.nextChunk": { argTypes: [null], result: VOID },
-    "readable.nextChunkDyn": { argTypes: [null], result: VOID },
-    "readable.fromArr": { argTypes: [null, BOOL], result: VOID },
-    "readable.resume": { argTypes: [null], result: VOID },
-    "readable.isPaused": { argTypes: [null], result: BOOL },
-    "readable.pipe": { argTypes: [null, null, BOOL], result: VOID },
-    "readable.unpipe": { argTypes: [null], result: VOID },
-    "readable.flowing": { argTypes: [null], result: VOID },
-    "writable.write": { argTypes: [null, BYTES_U8], result: BOOL },
-    "writable.writeStr": { argTypes: [null, STRING], result: BOOL },
-    "writable.writeU": { argTypes: [null, null], result: BOOL },
-    "writable.writeDyn": { argTypes: [null, DYN], result: BOOL },
-    "writable.end": { argTypes: [null, F64], result: VOID },
-    "writable.cork": { argTypes: [null], result: VOID },
-    "writable.uncork": { argTypes: [null], result: VOID },
-    "stream.destroy": { argTypes: [null], result: VOID },
-    "stream.destroyErr": { argTypes: [null, null], result: VOID },
-    "stream.iteratorClose": { argTypes: [null], result: VOID },
-    "stream.prop": { argTypes: [null, STRING], result: VOID },
-    "stream.errored": { argTypes: [null], result: VOID },
-    // node:assert: pass/negated/deep/hasMsg are frontend-computed bools; the
-    // message slot always carries a string ("" when hasMsg is false).
-    "assert.ok": { argTypes: [BOOL, STRING], result: VOID },
-    "assert.eqF64": { argTypes: [F64, F64, BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.eqBigInt": { argTypes: [BIGINT_T, BIGINT_T, BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.eqStr": { argTypes: [STRING, STRING, BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.eqBool": { argTypes: [BOOL, BOOL, BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.deepResult": { argTypes: [BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.sameValue": { argTypes: [F64, F64], result: BOOL },
-    // The deep-equality pair memo: both slots are program-dependent
-    // (any cycle-capable record/array/map type).
-    "assert.deqEnter": { argTypes: [null, null], result: BOOL },
-    "assert.deqLeave": { argTypes: [], result: VOID },
-    "assert.match": { argTypes: [STRING, REGEX, BOOL, STRING, BOOL], result: VOID },
-    "assert.throwsNone": { argTypes: [BOOL, STRING, BOOL, STRING, BOOL], result: VOID },
-    "assert.throwsMismatch": { argTypes: [STRING, { kind: "object", className: "%Error" }, STRING, BOOL], result: VOID },
-    "assert.throwsRegex": { argTypes: [REGEX, { kind: "object", className: "%Error" }, STRING, BOOL], result: VOID },
-    // Symbol strict equality (pointer identity; scr_symbol.c).
-    "assert.eqSym": { argTypes: [{ kind: "symbol" }, { kind: "symbol" }, BOOL, BOOL, STRING, BOOL], result: VOID },
-    // The equality quartet over checked-dynamic operands (the frontend
-    // boxes a static side into the checked-dynamic tree first).
-    "assert.eqDyn": { argTypes: [DYN, DYN, BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.looseResult": { argTypes: [BOOL, BOOL, STRING, STRING, STRING, BOOL], result: VOID },
-    // The throws(fn, {shape}) accumulator: begin/slot calls never throw;
-    // shapeEnd throws the Comparison diff. The error slot is the
-    // %Error-narrowed caught value.
-    "assert.shapeBegin": { argTypes: [{ kind: "object", className: "%Error" }], result: VOID },
-    "assert.shapeStr": { argTypes: [F64, STRING], result: VOID },
-    "assert.shapeRe": { argTypes: [F64, REGEX], result: VOID },
-    "assert.shapeEnd": { argTypes: [STRING, BOOL], result: VOID },
-    "assert.regexErrTest": { argTypes: [REGEX, { kind: "object", className: "%Error" }], result: BOOL },
-    "assert.unwantedRejection": { argTypes: [{ kind: "object", className: "%Error" }, STRING, BOOL], result: VOID },
-    "assert.unwantedError": { argTypes: [STRING, BOOL, STRING, BOOL], result: VOID },
-    "assert.noErrorPredicate": { argTypes: [DYN, DYN], result: BOOL },
-    "assert.regexDynTest": { argTypes: [REGEX, DYN], result: BOOL },
-    "assert.expectsErrDyn": { argTypes: [DYN, DYN, STRING, BOOL], result: VOID },
-    // assert.ifError's typed entries (always throw; unit args never
-    // lower). The error slot is program-dependent — any %Error-hierarchy
-    // class, root or subclass (the insp.error precedent, null slot).
-    "assert.ifErrorErr": { argTypes: [null], result: VOID },
-    "assert.ifErrorF64": { argTypes: [F64], result: VOID },
-    "assert.ifErrorStr": { argTypes: [STRING], result: VOID },
-    "assert.ifErrorBool": { argTypes: [BOOL], result: VOID },
-    "assert.ifErrorDyn": { argTypes: [DYN], result: VOID },
-    // Bytes equality: the two value slots are any bytes kind (the frontend
-    // gates both sides to ONE static bytes type; the libCall case checks
-    // the kind and the pair below).
-    "assert.refEqBytes": { argTypes: [null, null, BOOL, BOOL, STRING, BOOL], result: VOID },
-    "assert.refEqFn": { argTypes: [null, null, BOOL, STRING, BOOL], result: VOID },
-    "assert.bytesDeepEq": { argTypes: [null, null, BOOL], result: BOOL },
-    // util.inspect: the error receiver is program-dependent (a builtin or
-    // user error class — the error.toString precedent, null slot).
-    "insp.f64": { argTypes: [F64], result: STRING },
-    "insp.jsonDyn": { argTypes: [DYN], result: STRING },
-    "insp.str": { argTypes: [STRING], result: STRING },
-    "insp.regex": { argTypes: [REGEX], result: STRING },
-    "insp.buffer": { argTypes: [BYTES_U8], result: STRING },
-    "insp.error": { argTypes: [null, F64, F64], result: STRING },
-    "insp.dyn": { argTypes: [DYN, F64, F64], result: STRING },
-    "insp.dynS": { argTypes: [DYN, F64], result: STRING },
-    "insp.jsval": { argTypes: [JSVAL, F64, F64], result: STRING },
-    "insp.begin": { argTypes: [F64], result: VOID },
-    "insp.entry": { argTypes: [STRING, BOOL], result: VOID },
-    // Circular references: the receiver slot is program-dependent (any
-    // cycle-capable record/array/map/class type — the insp.error precedent).
-    "insp.circCheck": { argTypes: [null], result: F64 },
-    "insp.seenPush": { argTypes: [null], result: VOID },
-    "insp.refWrap": { argTypes: [null, STRING], result: STRING },
-    "insp.circular": { argTypes: [F64], result: STRING },
-    "insp.key": { argTypes: [STRING], result: STRING },
-    "insp.moreItems": { argTypes: [F64], result: STRING },
-    "insp.end": { argTypes: [STRING, STRING, STRING, F64, BOOL, BOOL], result: STRING },
-    "strdec.write": { argTypes: [STRING, F64, BYTES_U8], result: STRING },
-    "strdec.next": { argTypes: [STRING, F64, BYTES_U8], result: F64 },
-    "strdec.end": { argTypes: [STRING, F64], result: STRING },
-    // node:readline: the interface handle is f64; the callbacks' func types
-    // are program-dependent (zero-param or (answer: string) — the emitter
-    // picks the adapter), so those slots are null like child.onExit's.
-    "rl.create": { argTypes: [], result: F64 },
-    "rl.question": { argTypes: [F64, STRING, null], result: VOID },
-    "rl.close": { argTypes: [F64], result: VOID },
-    "rl.onClose": { argTypes: [F64, null], result: VOID },
-    "tp.setTimeout": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
-    "tp.setImmediate": { argTypes: [], result: { kind: "promise", inner: VOID } },
-    "dc.channel": { argTypes: [STRING], result: F64 },
-    "dc.subscribe": { argTypes: [STRING, DYN], result: VOID },
-    "dc.unsubscribe": { argTypes: [STRING, DYN], result: BOOL },
-    "dc.hasSubscribers": { argTypes: [STRING], result: BOOL },
-    "dc.publish": { argTypes: [F64, DYN], result: VOID },
-    "dc.chanSubscribe": { argTypes: [F64, DYN], result: VOID },
-    "dc.chanUnsubscribe": { argTypes: [F64, DYN], result: BOOL },
-    "dc.chanHasSubscribers": { argTypes: [F64], result: BOOL },
-    "dc.chanName": { argTypes: [F64], result: STRING },
-    "timers.setImmediateFnValue": { argTypes: [], result: DYN },
-    "timers.immediatePromise": { argTypes: [], result: { kind: "promise", inner: DYN } },
-    "dc.tracingChannel": { argTypes: [STRING], result: F64 },
-    "dc.tracingChannelOf": { argTypes: [F64, F64, F64, F64, F64], result: F64 },
-    "dc.tcChannel": { argTypes: [F64, F64], result: F64 },
-    "dc.tcHasSubscribers": { argTypes: [F64], result: BOOL },
-    "dc.tcSubscribe": { argTypes: [F64, DYN], result: VOID },
-    "dc.tcUnsubscribe": { argTypes: [F64, DYN], result: BOOL },
-    "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 },
-    "process.offRejectionHandled": { argTypes: [DYN], result: VOID },
-    "process.onWarning": { argTypes: [DYN], result: VOID },
-    "process.offWarning": { argTypes: [DYN], result: VOID },
-    "process.emitWarning": { argTypes: [DYN], result: VOID },
-    "async.awaitDyn": { argTypes: [DYN], result: DYN },
-    "async.hop": { argTypes: [], result: VOID },
-    "als.new": { argTypes: [], result: F64 },
-    "als.get": { argTypes: [F64], result: DYN },
-    "als.run": { argTypes: [F64, DYN, DYN, DYN], result: DYN },
-    "als.exitRun": { argTypes: [F64, DYN, DYN], result: DYN },
-    "als.enterWith": { argTypes: [F64, DYN], result: VOID },
-    "als.disable": { argTypes: [F64], result: VOID },
-    "dc.chanBindStore": { argTypes: [F64, F64, DYN], result: VOID },
-    "dc.chanUnbindStore": { argTypes: [F64, F64], result: BOOL },
-    "dc.chanRunStores": { argTypes: [F64, DYN, DYN, DYN, DYN], result: DYN },
-    "number.isFinite": { argTypes: [F64], result: BOOL },
-    "number.isNaN": { argTypes: [F64], result: BOOL },
-    "number.isInteger": { argTypes: [F64], result: BOOL },
-    "number.isSafeInteger": { argTypes: [F64], result: BOOL },
-    "date.now": { argTypes: [], result: F64 },
-    "date.newNow": { argTypes: [], result: DATE_T },
-    "date.newMs": { argTypes: [F64], result: DATE_T },
-    "date.newString": { argTypes: [STRING], result: DATE_T },
-    "date.parse": { argTypes: [STRING], result: F64 },
-    "date.getTime": { argTypes: [DATE_T], result: F64 },
-    "date.valueOf": { argTypes: [DATE_T], result: F64 },
-    "date.toISOString": { argTypes: [F64], result: STRING },
-    "date.toISOStringValue": { argTypes: [DATE_T], result: STRING },
-    "date.getFullYear": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCFullYear": { argTypes: [DATE_T], result: F64 },
-    "date.getMonth": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCMonth": { argTypes: [DATE_T], result: F64 },
-    "date.getDate": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCDate": { argTypes: [DATE_T], result: F64 },
-    "date.getDay": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCDay": { argTypes: [DATE_T], result: F64 },
-    "date.getHours": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCHours": { argTypes: [DATE_T], result: F64 },
-    "date.getMinutes": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCMinutes": { argTypes: [DATE_T], result: F64 },
-    "date.getSeconds": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCSeconds": { argTypes: [DATE_T], result: F64 },
-    "date.getMilliseconds": { argTypes: [DATE_T], result: F64 },
-    "date.getUTCMilliseconds": { argTypes: [DATE_T], result: F64 },
-    "date.getTimezoneOffset": { argTypes: [DATE_T], result: F64 },
-    "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 },
-    "text.decoderName": { argTypes: [F64], result: STRING },
-    "text.encodeInto": { argTypes: [DYN, DYN], result: DYN },
-    "buffer.isAscii": { argTypes: [DYN], result: BOOL },
-    "buffer.isUtf8": { argTypes: [DYN], result: BOOL },
-    "buffer.transcode": { argTypes: [DYN, DYN, DYN], result: BYTES_U8 },
-    "fs.mkdirRecursiveSync": { argTypes: [STRING], result: VOID },
-    "fs.rmOptsSync": { argTypes: [STRING, BOOL, BOOL], result: VOID },
-    "fs.rmRetrySync": { argTypes: [STRING, BOOL, BOOL, F64, F64], result: VOID },
-    "fs.mkdtempSync": { argTypes: [STRING], result: STRING },
-    "fs.accessSync": { argTypes: [STRING, F64], result: VOID },
-    "fs.readFdSync": { argTypes: [F64, STRING], result: STRING },
-    "fs.readFdSyncBytes": { argTypes: [F64], result: BYTES_U8 },
-    "process.isTTY": { argTypes: [F64], result: BOOL },
-    // Like process.envGet: the result is the module's interned
-    // `number | undefined` union — checked by arms in the libCall case.
-    "process.columns": { argTypes: [F64], result: VOID },
-    "process.rows": { argTypes: [F64], result: VOID },
-    "process.stdinDestroy": { argTypes: [], result: VOID },
-    "process.stdinSetRawMode": { argTypes: [BOOL], result: VOID },
-    // 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 },
-};
+import { LIB_FN_SIGS } from "./builtin-signatures.js";
+import { REGEX_INTRINSIC_SIGS, STR_INTRINSIC_SIGS } from "./intrinsic-signatures.js";
 /** True for an object type naming a runtime-provided error class. */
 function isBuiltinErrorObject(t) {
     return t.kind === "object" && RUNTIME_ERROR_CLASSES.has(t.className);
@@ -1597,12 +21,23 @@ function isBuiltinErrorObject(t) {
  * the body/call-site split is spelled out in the validator. */
 function callSiteReturnType(fn) {
     if (fn.async && fn.generator !== undefined) {
-        return { kind: "generator", async: true, yieldT: fn.generator.yieldT, retT: fn.returnType, nextT: fn.generator.nextT };
+        return {
+            kind: "generator",
+            async: true,
+            yieldT: fn.generator.yieldT,
+            retT: fn.returnType,
+            nextT: fn.generator.nextT,
+        };
     }
     if (fn.async)
         return { kind: "promise", inner: fn.returnType };
     if (fn.generator !== undefined) {
-        return { kind: "generator", yieldT: fn.generator.yieldT, retT: fn.returnType, nextT: fn.generator.nextT };
+        return {
+            kind: "generator",
+            yieldT: fn.generator.yieldT,
+            retT: fn.returnType,
+            nextT: fn.generator.nextT,
+        };
     }
     return fn.returnType;
 }
@@ -1618,7 +53,20 @@ export function validateModule(mod) {
     const ffiByName = new Map();
     const ffiSymbols = new Set();
     const moduleLoc = { file: mod.sourceFile, start: 0, end: 0 };
+    if (mod.workers !== undefined && typeof mod.workers !== "boolean")
+        errors.push({ message: "worker execution mode must be a boolean", loc: moduleLoc });
+    if (mod.workers && (mod.lib !== undefined || mod.embedded !== undefined))
+        errors.push({
+            message: "worker execution requires a native static executable",
+            loc: moduleLoc,
+        });
     for (const entry of mod.ffiImports ?? []) {
+        if (mod.workers &&
+            entry.params.some((parameter) => isFfiCallbackParam(parameter) && parameter.callback.invoke === "foreign"))
+            errors.push({
+                message: "worker execution cannot install foreign-thread callbacks",
+                loc: moduleLoc,
+            });
         if (ffiByName.has(entry.name)) {
             errors.push({ message: `duplicate FFI binding "${entry.name}"`, loc: moduleLoc });
         }
@@ -1631,20 +79,32 @@ 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 }); };
+            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)
+                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" ||
+                if (entry.params.length !== 0 ||
+                    entry.returns !== "void" ||
+                    target?.callbackOperation !== "register" ||
                     target.library !== entry.library)
                     fail("has an invalid release target or ABI");
             }
@@ -1652,31 +112,52 @@ export function validateModule(mod) {
                 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 });
+            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))
                 continue;
             if (ids.has(param.callback.id)) {
-                errors.push({ message: `FFI binding "${entry.name}" has duplicate callback id "${param.callback.id}"`, loc: moduleLoc });
+                errors.push({
+                    message: `FFI binding "${entry.name}" has duplicate callback id "${param.callback.id}"`,
+                    loc: moduleLoc,
+                });
             }
             ids.add(param.callback.id);
             if (param.callback.invoke !== "script-thread" && param.callback.invoke !== "foreign") {
-                errors.push({ message: `FFI callback "${entry.name}:${param.callback.id}" has invalid invoke mode`, loc: moduleLoc });
+                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 });
+                    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 });
+                    errors.push({
+                        message: `FFI foreign callback "${entry.name}:${param.callback.id}" is not retained`,
+                        loc: moduleLoc,
+                    });
                 }
                 if (param.callback.returns !== "void") {
-                    errors.push({ message: `FFI foreign callback "${entry.name}:${param.callback.id}" does not return void`, loc: moduleLoc });
+                    errors.push({
+                        message: `FFI foreign callback "${entry.name}:${param.callback.id}" does not return void`,
+                        loc: moduleLoc,
+                    });
                 }
                 if (!param.callback.params.some(isFfiContextParam)) {
-                    errors.push({ message: `FFI foreign callback "${entry.name}:${param.callback.id}" has no context`, loc: moduleLoc });
+                    errors.push({
+                        message: `FFI foreign callback "${entry.name}:${param.callback.id}" has no context`,
+                        loc: moduleLoc,
+                    });
                 }
             }
             if (param.callback.lifetime === "retained") {
@@ -1685,7 +166,10 @@ export function validateModule(mod) {
             const hasInnerContext = param.callback.params.some(isFfiContextParam);
             const outerContexts = entry.params.filter((candidate) => isFfiContextParam(candidate) && candidate.context === param.callback.id).length;
             if (hasInnerContext !== (outerContexts === 1)) {
-                errors.push({ message: `FFI callback "${entry.name}:${param.callback.id}" has inconsistent context slots`, loc: moduleLoc });
+                errors.push({
+                    message: `FFI callback "${entry.name}:${param.callback.id}" has inconsistent context slots`,
+                    loc: moduleLoc,
+                });
             }
         }
     }
@@ -1695,7 +179,10 @@ export function validateModule(mod) {
                 continue;
             const target = retainedFfiCallbacks.get(param.callback.release);
             if (target === undefined) {
-                errors.push({ message: `FFI release "${entry.name}:${param.callback.release}" has no retained target`, loc: moduleLoc });
+                errors.push({
+                    message: `FFI release "${entry.name}:${param.callback.release}" has no retained target`,
+                    loc: moduleLoc,
+                });
                 continue;
             }
             // A call registering its own release target defeats the emitted
@@ -1704,7 +191,10 @@ export function validateModule(mod) {
             const registeredBySameCall = entry.params.some((candidate) => isFfiCallbackParam(candidate) &&
                 `${entry.name}:${candidate.callback.id}` === param.callback.release);
             if (registeredBySameCall) {
-                errors.push({ message: `FFI release "${entry.name}:${param.callback.release}" targets a retained callback registered by the same call`, loc: moduleLoc });
+                errors.push({
+                    message: `FFI release "${entry.name}:${param.callback.release}" targets a retained callback registered by the same call`,
+                    loc: moduleLoc,
+                });
             }
             // Structural ABI comparison: a params entry is a value-class string
             // or a {context} object. Key order and incidental object shape must
@@ -1719,12 +209,18 @@ export function validateModule(mod) {
                 }) &&
                 param.callback.returns === target.returns;
             if (!inherited) {
-                errors.push({ message: `FFI release "${entry.name}:${param.callback.release}" does not inherit its target ABI`, loc: moduleLoc });
+                errors.push({
+                    message: `FFI release "${entry.name}:${param.callback.release}" does not inherit its target ABI`,
+                    loc: moduleLoc,
+                });
             }
             const hasInnerContext = target.params.some(isFfiContextParam);
             const outerContexts = entry.params.filter((candidate) => isFfiContextParam(candidate) && candidate.context === param.callback.release).length;
             if (hasInnerContext !== (outerContexts === 1)) {
-                errors.push({ message: `FFI release "${entry.name}:${param.callback.release}" has inconsistent context slots`, loc: moduleLoc });
+                errors.push({
+                    message: `FFI release "${entry.name}:${param.callback.release}" has inconsistent context slots`,
+                    loc: moduleLoc,
+                });
             }
         }
     }
@@ -1737,14 +233,23 @@ export function validateModule(mod) {
         for (const e of mod.lib.exports) {
             const fn = functionsByName.get(e.fnName);
             if (!fn) {
-                errors.push({ message: `library export "${e.symbol}": missing function "${e.fnName}"`, loc: entryLoc });
+                errors.push({
+                    message: `library export "${e.symbol}": missing function "${e.fnName}"`,
+                    loc: entryLoc,
+                });
                 continue;
             }
             if (fn.async === true || fn.generator !== undefined) {
-                errors.push({ message: `library export "${e.symbol}": "${e.fnName}" is async/generator`, loc: fn.loc });
+                errors.push({
+                    message: `library export "${e.symbol}": "${e.fnName}" is async/generator`,
+                    loc: fn.loc,
+                });
             }
             if (fn.captures !== undefined) {
-                errors.push({ message: `library export "${e.symbol}": "${e.fnName}" captures an environment`, loc: fn.loc });
+                errors.push({
+                    message: `library export "${e.symbol}": "${e.fnName}" captures an environment`,
+                    loc: fn.loc,
+                });
             }
             if (fn.params.length !== e.params.length) {
                 errors.push({
@@ -1776,27 +281,39 @@ export function validateModule(mod) {
             }
         }
         if (!functionsByName.has(mod.entry)) {
-            errors.push({ message: `library module missing its entry function "${mod.entry}"`, loc: entryLoc });
+            errors.push({
+                message: `library module missing its entry function "${mod.entry}"`,
+                loc: entryLoc,
+            });
         }
         // Host-callback channels: the register symbol and the channel list are
         // paired (the profile loader refuses otherwise, so a miss here is a
         // compiler bug), slots are the declaration order, and every channel
         // has its matching ffiImport (the lowering recognizes calls by it).
         const cbs = mod.lib.callbacks ?? [];
-        if ((cbs.length > 0) !== (mod.lib.callbackRegisterSymbol !== undefined)) {
-            errors.push({ message: "library callbacks and callbackRegisterSymbol must be present together", loc: entryLoc });
+        if (cbs.length > 0 !== (mod.lib.callbackRegisterSymbol !== undefined)) {
+            errors.push({
+                message: "library callbacks and callbackRegisterSymbol must be present together",
+                loc: entryLoc,
+            });
         }
         const cbNames = new Set();
         cbs.forEach((cb, i) => {
             if (cb.slot !== i) {
-                errors.push({ message: `library callback "${cb.name}": slot ${cb.slot} out of declaration order (expected ${i})`, loc: entryLoc });
+                errors.push({
+                    message: `library callback "${cb.name}": slot ${cb.slot} out of declaration order (expected ${i})`,
+                    loc: entryLoc,
+                });
             }
             if (cbNames.has(cb.name)) {
                 errors.push({ message: `duplicate library callback channel "${cb.name}"`, loc: entryLoc });
             }
             cbNames.add(cb.name);
             if (!(mod.ffiImports ?? []).some((f) => f.name === cb.name)) {
-                errors.push({ message: `library callback "${cb.name}" has no matching ffiImport`, loc: entryLoc });
+                errors.push({
+                    message: `library callback "${cb.name}" has no matching ffiImport`,
+                    loc: entryLoc,
+                });
             }
         });
     }
@@ -1808,49 +325,81 @@ export function validateModule(mod) {
         }
         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 });
+            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 });
+                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) {
+            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) {
+            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.tracksOwnFields && (cls.runtime || cls.fields.find((field) => field.name === DYN_CLASS_PROPERTIES)?.type.kind !== "dyn")) {
-            errors.push({ message: `class ${cls.name}: field presence tracking requires a native dyn property bag`, loc: cls.loc });
+        if (cls.tracksOwnFields &&
+            (cls.runtime ||
+                cls.fields.find((field) => field.name === DYN_CLASS_PROPERTIES)?.type.kind !== "dyn")) {
+            errors.push({
+                message: `class ${cls.name}: field presence tracking requires a native dyn property bag`,
+                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 (!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 });
+            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)) {
+            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 });
             }
         }
@@ -1864,7 +413,10 @@ export function validateModule(mod) {
             else
                 seen.set(f.name, f.type);
             if (isUnitType(f.type)) {
-                errors.push({ message: `class ${cls.name}: field "${f.name}" is ${f.type.kind}`, loc: cls.loc });
+                errors.push({
+                    message: `class ${cls.name}: field "${f.name}" is ${f.type.kind}`,
+                    loc: cls.loc,
+                });
             }
         }
         // Duplicate class names, like classesByName, select the last declaration.
@@ -1879,10 +431,16 @@ export function validateModule(mod) {
         // module function exists for them (and must not).
         for (const m of cls.abstractMethods ?? []) {
             if (!cls.methods?.includes(m)) {
-                errors.push({ message: `class ${cls.name}: abstract method "${m}" not in methods`, loc: cls.loc });
+                errors.push({
+                    message: `class ${cls.name}: abstract method "${m}" not in methods`,
+                    loc: cls.loc,
+                });
             }
             if (functionsByName.has(`%${cls.name}.${m}`)) {
-                errors.push({ message: `class ${cls.name}: abstract method "${m}" has a function`, loc: cls.loc });
+                errors.push({
+                    message: `class ${cls.name}: abstract method "${m}" has a function`,
+                    loc: cls.loc,
+                });
             }
         }
         for (const m of cls.methods ?? []) {
@@ -1904,8 +462,13 @@ 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 });
+        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) {
@@ -1923,27 +486,47 @@ export function validateModule(mod) {
             });
         }
     }
-    // Generic-class instantiations: the named FAMILY exists and is a proper
-    // ancestor (the class object's interval is read off it — see IrClassDef).
+    // Family membership is nominal; an instance may have a separately
+    // specialized base. The family's inherited prefix must remain valid.
+    const physicalRoot = (cls) => {
+        const seen = new Set();
+        let current = cls;
+        while (current?.base !== undefined) {
+            if (seen.has(current.name))
+                return undefined;
+            seen.add(current.name);
+            current = classesByName.get(current.base);
+        }
+        return current;
+    };
     for (const cls of mod.classes ?? []) {
         if (cls.genericOf === undefined)
             continue;
         const family = classesByName.get(cls.genericOf);
         if (!family) {
-            errors.push({ message: `class ${cls.name}: undeclared generic family "${cls.genericOf}"`, loc: cls.loc });
-            continue;
+            errors.push({
+                message: `class ${cls.name}: undeclared generic family "${cls.genericOf}"`,
+                loc: cls.loc,
+            });
         }
-        let ancestor = false;
-        const seen = new Set();
-        for (let c = cls.base !== undefined ? classesByName.get(cls.base) : undefined; c && !seen.has(c.name); c = c.base !== undefined ? classesByName.get(c.base) : undefined) {
-            seen.add(c.name);
-            if (c.name === cls.genericOf) {
-                ancestor = true;
-                break;
-            }
+        else if (family === cls || family.genericOf !== undefined) {
+            errors.push({
+                message: `class ${cls.name}: generic family "${cls.genericOf}" must name an erased declaration`,
+                loc: cls.loc,
+            });
+        }
+        else if (physicalRoot(cls) !== physicalRoot(family)) {
+            errors.push({
+                message: `class ${cls.name}: generic family "${cls.genericOf}" has a different storage root`,
+                loc: cls.loc,
+            });
         }
-        if (!ancestor) {
-            errors.push({ message: `class ${cls.name}: generic family "${cls.genericOf}" is not an ancestor`, loc: cls.loc });
+        else if (family.fields.some((field, index) => cls.fields[index]?.name !== field.name ||
+            !typeEquals(cls.fields[index].type, field.type))) {
+            errors.push({
+                message: `class ${cls.name}: generic family "${cls.genericOf}" has an incompatible prefix`,
+                loc: cls.loc,
+            });
         }
     }
     const noLoc = { file: mod.sourceFile, start: 0, end: 0 };
@@ -1966,7 +549,10 @@ export function validateModule(mod) {
             // unit field is as malformed as a void one. dyn and jsval slots
             // are valid; both are refcounted values held by the record shape.
             if (f.type.kind === "void" || isUnitType(f.type)) {
-                errors.push({ message: `record ${rec.id}: field "${f.name}" is ${f.type.kind}`, loc: noLoc });
+                errors.push({
+                    message: `record ${rec.id}: field "${f.name}" is ${f.type.kind}`,
+                    loc: noLoc,
+                });
             }
             if (f.type.kind === "record" && !recordIds.has(f.type.shapeId)) {
                 errors.push({
@@ -1980,13 +566,18 @@ export function validateModule(mod) {
         // shapes share one index. All indexes belong to this validation call.
         recordValidation.set(rec.id, {
             fields,
-            initializationFields: fields.size === rec.fields.length ? fields : new Map(rec.fields.map((field) => [field.name, field.type])),
+            initializationFields: fields.size === rec.fields.length
+                ? fields
+                : new Map(rec.fields.map((field) => [field.name, field.type])),
             hasAccessorSlots: shapeHasAccessorSlots(rec),
         });
         // Canonical order is the shape's identity — enforce it.
         const sorted = [...rec.fields].map((f) => f.name).sort();
         if (rec.fields.some((f, i) => f.name !== sorted[i])) {
-            errors.push({ message: `record ${rec.id}: fields are not in canonical (sorted) order`, loc: noLoc });
+            errors.push({
+                message: `record ${rec.id}: fields are not in canonical (sorted) order`,
+                loc: noLoc,
+            });
         }
         // Tuple shapes carry exactly the positional fields "0".."n-1" (arity =
         // field count) — anything else has no honest index/JSON story.
@@ -1999,13 +590,17 @@ export function validateModule(mod) {
                     break;
                 }
             }
-            if (rec.fields.length === 0 ||
-                names.size !== rec.fields.length ||
-                !positionsComplete) {
-                errors.push({ message: `record ${rec.id}: tuple fields are not "0".."${rec.fields.length - 1}"`, loc: noLoc });
+            if (rec.fields.length === 0 || names.size !== rec.fields.length || !positionsComplete) {
+                errors.push({
+                    message: `record ${rec.id}: tuple fields are not "0".."${rec.fields.length - 1}"`,
+                    loc: noLoc,
+                });
             }
             if (rec.indexValue) {
-                errors.push({ message: `record ${rec.id}: a tuple cannot carry an index signature`, loc: noLoc });
+                errors.push({
+                    message: `record ${rec.id}: a tuple cannot carry an index signature`,
+                    loc: noLoc,
+                });
             }
         }
         // Index-signature shapes: the overflow value type is fenced to the map
@@ -2036,12 +631,21 @@ export function validateModule(mod) {
                 const arm = u.arms[candidate.tag];
                 const record = arm?.kind === "record" ? recordsById.get(arm.shapeId) : undefined;
                 const member = record ? recordValidation.get(record.id)?.fields.get(field) : undefined;
-                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 });
+                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 });
+                    errors.push({
+                        message: `union ${u.id}: empty discriminant values for tag ${candidate.tag}`,
+                        loc: noLoc,
+                    });
                 }
                 for (const value of candidate.values) {
                     if (value === undefined) {
@@ -2049,20 +653,31 @@ export function validateModule(mod) {
                         continue;
                     }
                     const fieldTypes = member?.kind === "union"
-                        ? unionsById.get(member.unionId)?.arms ?? [] : member ? [member] : [];
-                    const valid = fieldTypes.some((type) => typeof value === "string" ? type.kind === "string"
-                        : typeof value === "boolean" ? type.kind === "bool"
+                        ? (unionsById.get(member.unionId)?.arms ?? [])
+                        : member
+                            ? [member]
+                            : [];
+                    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 });
+                        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 });
+                    errors.push({
+                        message: `union ${u.id}: missing discriminant for record arm ${tag}`,
+                        loc: noLoc,
+                    });
                 }
             }
         }
@@ -2081,7 +696,10 @@ export function validateModule(mod) {
             }
             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 });
+                errors.push({
+                    message: `union ${u.id}: ${arm.kind} arm ${i} beside non-unit arms`,
+                    loc: noLoc,
+                });
             }
             if (arm.kind === "record" && !recordsById.has(arm.shapeId)) {
                 errors.push({
@@ -2173,7 +791,10 @@ 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 });
+            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 });
@@ -2216,7 +837,9 @@ export function validateModule(mod) {
     // membership, and virtual-call resolution local to this validation invocation.
     const classValidation = {
         fields: classFields,
-        hierarchy: new Set(), implementations: new Map(), virtualCalls: new Map(),
+        hierarchy: new Set(),
+        implementations: new Map(),
+        virtualCalls: new Map(),
     };
     for (const cls of classesByName.values()) {
         if (cls.base !== undefined) {
@@ -2235,11 +858,11 @@ export function validateModule(mod) {
         }
     }
     for (const fn of mod.functions) {
-        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors);
+        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true);
     }
     return errors;
 }
-function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors) {
+function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers) {
     const locals = new Map(fn.locals.map((l) => [l.id, l]));
     const err = (message, loc) => errors.push({ message: `in ${fn.name}: ${message}`, loc });
     const asyncCaches = [
@@ -2272,13 +895,37 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     if (fn.asyncCycleCacheGlobal !== undefined && fn.asyncCacheGlobal === undefined) {
         err("an asyncCycleCacheGlobal requires a module asyncCacheGlobal", fn.loc);
     }
-    // The class graph's two questions (upcast/downcast/instanceOf/virtualCall
-    // legality): strict-descendant tests over the base links, and hierarchy
-    // membership (a class that extends or is extended).
+    // Virtual slots and constructor ABIs follow physical inheritance only.
+    // Erased family identity does not supply their specialized layout or ABI.
+    const isPhysicalSubclass = (sub, sup) => {
+        const seen = new Set([sub]);
+        for (let c = classes.get(sub)?.base; c !== undefined; c = classes.get(c)?.base) {
+            if (seen.has(c))
+                return false;
+            seen.add(c);
+            if (c === sup)
+                return true;
+        }
+        return false;
+    };
+    // Object casts may also recover an erased family. The module-level
+    // prefix check validates the fields exposed by that view.
     const isStrictSubclass = (sub, sup) => {
-        for (let c = classes.get(sub); c?.base !== undefined; c = classes.get(c.base)) {
-            if (c.base === sup)
+        const seen = new Set();
+        for (let c = classes.get(sub); c; c = c.base === undefined ? undefined : classes.get(c.base)) {
+            if (seen.has(c.name))
+                return false;
+            seen.add(c.name);
+            if (c.name !== sub && c.name === sup)
                 return true;
+            const families = new Set();
+            for (let family = c.genericOf === undefined ? undefined : classes.get(c.genericOf); family; family = family.base === undefined ? undefined : classes.get(family.base)) {
+                if (families.has(family.name))
+                    return false;
+                families.add(family.name);
+                if (family.name === sup)
+                    return true;
+            }
         }
         return false;
     };
@@ -2305,7 +952,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         if (declared) {
             // Preserve class-table order when choosing an abstract slot's ABI.
             for (const c of classValidation.implementations.get(method) ?? []) {
-                if (!isStrictSubclass(c.name, className))
+                if (!isPhysicalSubclass(c.name, className))
                     continue;
                 hasOverride = true;
                 implementation ??= functions.get(`%${c.name}.${method}`);
@@ -2366,7 +1013,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // Same-kind mismatches (func vs func, record vs record) would be
             // unreadable as bare kinds — the structural keys show WHERE the two
             // types diverge.
-            const detail = want.kind === expr.type.kind ? ` (expected ${typeKey(want)}, got ${typeKey(expr.type)})` : "";
+            const detail = want.kind === expr.type.kind
+                ? ` (expected ${typeKey(want)}, got ${typeKey(expr.type)})`
+                : "";
             err(`${what}: expected ${want.kind}, got ${expr.type.kind}${detail}`, expr.loc);
         }
     };
@@ -2465,8 +1114,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 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") {
+                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")
@@ -2616,7 +1269,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // 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.
-                if (e.type.kind !== "f64" && !(e.type.kind === "procStream" && (e.value === 1 || e.value === 2))) {
+                if (e.type.kind !== "f64" &&
+                    !(e.type.kind === "procStream" && (e.value === 1 || e.value === 2))) {
                     err("numLit must be f64", e.loc);
                 }
                 break;
@@ -2783,7 +1437,22 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // choose ARRAY_VALUE versus ARRAY_UNDEFINED before the final result
                 // 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"]);
+                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);
@@ -3024,7 +1693,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (!helper) {
                         err(`orDefault retag calls undeclared function "${e.retag}"`, e.loc);
                     }
-                    else if (helper.params.length !== 1 || !typeEquals(helper.params[0].type, e.left.type)) {
+                    else if (helper.params.length !== 1 ||
+                        !typeEquals(helper.params[0].type, e.left.type)) {
                         err(`orDefault retag ${e.retag} must take exactly the left union`, e.loc);
                     }
                     else if (!typeEquals(callSiteReturnType(helper), e.type)) {
@@ -3049,8 +1719,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (!def) {
                         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 === "bigint" || a.kind === "bool" ||
+                    else if (!def.arms.every((a) => a.kind === "undefinedT" ||
+                        a.kind === "nullT" ||
+                        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);
                     }
@@ -3250,11 +1924,29 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // view; dataViewNew and byteOffset take ANY elem kind (views form
                 // over any typed array's storage, owners answer byteOffset 0).
                 const isDv = e.method.startsWith("dvGet") || e.method.startsWith("dvSet");
-                const isNum = e.method === "readNum" || e.method === "writeNum" || e.method === "readNumVar" || e.method === "writeNumVar";
+                const isNum = e.method === "readNum" ||
+                    e.method === "writeNum" ||
+                    e.method === "readNumVar" ||
+                    e.method === "writeNumVar";
                 const U8_ONLY_EXTRA = new Set([
-                    "toString", "toStringVar", "equals", "compareBuf", "indexOf", "lastIndexOf", "includes",
-                    "indexOfNum", "lastIndexOfNum", "includesNum", "fill", "fillNum", "fillStr",
-                    "copy", "swap16", "swap32", "swap64", "writeStr",
+                    "toString",
+                    "toStringVar",
+                    "equals",
+                    "compareBuf",
+                    "indexOf",
+                    "lastIndexOf",
+                    "includes",
+                    "indexOfNum",
+                    "lastIndexOfNum",
+                    "includesNum",
+                    "fill",
+                    "fillNum",
+                    "fillStr",
+                    "copy",
+                    "swap16",
+                    "swap32",
+                    "swap64",
+                    "writeStr",
                 ]);
                 const u8Only = U8_ONLY_EXTRA.has(e.method) || isNum || isDv;
                 if (u8Only && recv.elem !== "u8") {
@@ -3266,7 +1958,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 if (isNum && e.args[0]?.kind !== "strLit") {
                     err(`bytesIntrinsic ${e.method} args[0] must be a strLit kind token`, e.loc);
                 }
-                else if (isNum && e.args[0]?.kind === "strLit" && !validByteNumberToken(e.method, e.args[0].value)) {
+                else if (isNum &&
+                    e.args[0]?.kind === "strLit" &&
+                    !validByteNumberToken(e.method, e.args[0].value)) {
                     err(`bytesIntrinsic ${e.method} invalid kind token '${e.args[0].value}'`, e.loc);
                 }
                 // fillStr/writeStr carry their NORMALIZED encoding as args[1],
@@ -3302,49 +1996,61 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // Object.hasOwn: "toString" is a real method name here and must
                 // not answer from Object.prototype.
                 const extraSig = Object.hasOwn(EXTRA_SIGS, e.method) ? EXTRA_SIGS[e.method] : undefined;
-                const sig = extraSig ?? (e.method === "length" || e.method === "byteLength" || e.method === "byteOffset"
-                    ? { argTypes: [], minArgs: 0, result: F64 }
-                    : e.method === "get"
-                        ? { argTypes: [F64], minArgs: 1, result: F64 }
-                        : e.method === "slice" || e.method === "subarray"
-                            ? { argTypes: [F64, F64], minArgs: 0, result: bytesOf(recv.elem) }
-                            : e.method === "toReversed"
-                                ? { argTypes: [], minArgs: 0, result: bytesOf(recv.elem) }
-                                : e.method === "with"
-                                    ? { argTypes: [F64, F64], minArgs: 2, result: bytesOf(recv.elem) }
-                                    : e.method === "join"
-                                        ? { argTypes: [STRING], minArgs: 1, result: STRING }
-                                        : e.method === "toArray"
-                                            ? { argTypes: [], minArgs: 0, result: arrayOf(F64) }
-                                            : e.method === "setFrom"
-                                                ? { 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"
-                                                        ? { argTypes: [STRING, F64], minArgs: 2, result: F64 }
-                                                        : e.method === "writeNum"
-                                                            ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
-                                                            : e.method === "readNumVar"
+                const sig = extraSig ??
+                    (e.method === "length" || e.method === "byteLength" || e.method === "byteOffset"
+                        ? { argTypes: [], minArgs: 0, result: F64 }
+                        : e.method === "get"
+                            ? { argTypes: [F64], minArgs: 1, result: F64 }
+                            : e.method === "slice" || e.method === "subarray"
+                                ? { argTypes: [F64, F64], minArgs: 0, result: bytesOf(recv.elem) }
+                                : e.method === "toReversed"
+                                    ? { argTypes: [], minArgs: 0, result: bytesOf(recv.elem) }
+                                    : e.method === "with"
+                                        ? { argTypes: [F64, F64], minArgs: 2, result: bytesOf(recv.elem) }
+                                        : e.method === "join"
+                                            ? { argTypes: [STRING], minArgs: 1, result: STRING }
+                                            : e.method === "toArray"
+                                                ? { argTypes: [], minArgs: 0, result: arrayOf(F64) }
+                                                : e.method === "setFrom"
+                                                    ? {
+                                                        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"
+                                                            ? { argTypes: [STRING, F64], minArgs: 2, result: F64 }
+                                                            : e.method === "writeNum"
                                                                 ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
-                                                                : e.method === "writeNumVar"
-                                                                    ? { argTypes: [STRING, F64, F64, F64], minArgs: 4, result: F64 }
-                                                                    : e.method === "dataViewNew"
-                                                                        ? { argTypes: [F64, F64], minArgs: 0, result: BYTES_U8 }
-                                                                        : e.method.startsWith("dvSet")
-                                                                            ? {
-                                                                                // dvSet*: [offset, value], the 8-bit setters take no littleEndian.
-                                                                                argTypes: e.method === "dvSetUint8" || e.method === "dvSetInt8"
-                                                                                    ? [F64, F64]
-                                                                                    : [F64, F64, BOOL],
-                                                                                minArgs: 2,
-                                                                                result: VOID,
-                                                                            }
-                                                                            : {
-                                                                                // dvGet*: the 8-bit getters take no littleEndian.
-                                                                                argTypes: e.method === "dvGetUint8" || e.method === "dvGetInt8" ? [F64] : [F64, BOOL],
-                                                                                minArgs: 1,
-                                                                                result: F64,
-                                                                            });
+                                                                : e.method === "readNumVar"
+                                                                    ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
+                                                                    : e.method === "writeNumVar"
+                                                                        ? { argTypes: [STRING, F64, F64, F64], minArgs: 4, result: F64 }
+                                                                        : e.method === "dataViewNew"
+                                                                            ? { argTypes: [F64, F64], minArgs: 0, result: BYTES_U8 }
+                                                                            : e.method.startsWith("dvSet")
+                                                                                ? {
+                                                                                    // dvSet*: [offset, value], the 8-bit setters take no littleEndian.
+                                                                                    argTypes: e.method === "dvSetUint8" || e.method === "dvSetInt8"
+                                                                                        ? [F64, F64]
+                                                                                        : [F64, F64, BOOL],
+                                                                                    minArgs: 2,
+                                                                                    result: VOID,
+                                                                                }
+                                                                                : {
+                                                                                    // dvGet*: the 8-bit getters take no littleEndian.
+                                                                                    argTypes: e.method === "dvGetUint8" || e.method === "dvGetInt8"
+                                                                                        ? [F64]
+                                                                                        : [F64, BOOL],
+                                                                                    minArgs: 1,
+                                                                                    result: F64,
+                                                                                });
                 if (e.args.length < sig.minArgs || e.args.length > sig.argTypes.length) {
                     err(`bytesIntrinsic ${e.method}: ${e.args.length} args`, e.loc);
                 }
@@ -3366,47 +2072,72 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     break;
                 }
                 const elem = e.receiver.type.elem;
-                const sig = e.method === "push" || e.method === "unshift"
-                    ? { argTypes: e.args.map(() => elem), result: F64 }
-                    : e.method === "pushSpread" || e.method === "concatSpread" || e.method === "unshiftSpread"
-                        ? { argTypes: [e.receiver.type], result: F64 }
-                        : e.method === "nextPresent" || e.method === "getNumber"
-                            ? { argTypes: [F64], result: F64 }
-                            : e.method === "indexEq"
-                                ? { argTypes: [F64, e.receiver.type, F64], result: BOOL }
-                                : e.method === "pop"
-                                    ? { argTypes: [], result: e.type } // union-checked below
-                                    : e.method === "indexOf"
-                                        ? { argTypes: [elem], result: F64 }
-                                        : e.method === "includes"
-                                            ? { argTypes: [elem], result: BOOL }
-                                            : e.method === "join"
-                                                ? { argTypes: [STRING], result: STRING }
-                                                : e.method === "slice"
-                                                    ? { argTypes: [F64, F64], result: e.receiver.type }
-                                                    : e.method === "toReversed"
-                                                        ? { argTypes: [], result: e.receiver.type }
-                                                        : e.method === "reverse"
-                                                            ? { argTypes: [], result: e.receiver.type }
-                                                            : e.method === "toSpliced"
-                                                                ? { argTypes: [F64, F64, e.receiver.type], result: e.receiver.type }
-                                                                : e.method === "with"
-                                                                    ? { argTypes: [F64, elem], result: e.receiver.type }
-                                                                    : e.method === "withUndefined"
-                                                                        ? { argTypes: [F64], result: e.receiver.type }
-                                                                        : e.method === "splice"
-                                                                            ? { argTypes: [F64, F64], result: e.receiver.type }
-                                                                            : e.method === "spliceInsert"
-                                                                                ? { argTypes: [F64, F64, e.receiver.type], result: e.receiver.type }
-                                                                                : e.method === "flatCopy" || e.method === "flatOne"
-                                                                                    ? { argTypes: [e.type], result: e.type }
-                                                                                    : e.method === "shift"
-                                                                                        ? { argTypes: [], result: e.type } // union-checked below
-                                                                                        : { argTypes: [], result: F64 }; // length
+                const sig = e.method === "copyWithin"
+                    ? { argTypes: [F64, F64, F64], result: e.receiver.type }
+                    : e.method === "fill"
+                        ? { argTypes: [elem, F64, F64], result: e.receiver.type }
+                        : e.method === "fillUndefined"
+                            ? { argTypes: [F64, F64], result: e.receiver.type }
+                            : e.method === "push" || e.method === "unshift"
+                                ? { argTypes: e.args.map(() => elem), result: F64 }
+                                : e.method === "pushSpread" ||
+                                    e.method === "concatSpread" ||
+                                    e.method === "unshiftSpread"
+                                    ? { argTypes: [e.receiver.type], result: F64 }
+                                    : e.method === "nextPresent" || e.method === "getNumber"
+                                        ? { argTypes: [F64], result: F64 }
+                                        : e.method === "indexEq"
+                                            ? { argTypes: [F64, e.receiver.type, F64], result: BOOL }
+                                            : e.method === "pop"
+                                                ? { argTypes: [], result: e.type } // union-checked below
+                                                : e.method === "indexOf"
+                                                    ? { argTypes: [elem], result: F64 }
+                                                    : e.method === "includes"
+                                                        ? { argTypes: [elem], result: BOOL }
+                                                        : e.method === "join"
+                                                            ? { argTypes: [STRING], result: STRING }
+                                                            : e.method === "slice"
+                                                                ? { argTypes: [F64, F64], result: e.receiver.type }
+                                                                : e.method === "toReversed" ||
+                                                                    e.method === "sortPrimitive" ||
+                                                                    e.method === "toSortedPrimitive"
+                                                                    ? { argTypes: [], result: e.receiver.type }
+                                                                    : e.method === "reverse"
+                                                                        ? { argTypes: [], result: e.receiver.type }
+                                                                        : e.method === "toSpliced"
+                                                                            ? {
+                                                                                argTypes: [F64, F64, e.receiver.type],
+                                                                                result: e.receiver.type,
+                                                                            }
+                                                                            : e.method === "with"
+                                                                                ? { argTypes: [F64, elem], result: e.receiver.type }
+                                                                                : e.method === "withUndefined"
+                                                                                    ? { argTypes: [F64], result: e.receiver.type }
+                                                                                    : e.method === "splice"
+                                                                                        ? { argTypes: [F64, F64], result: e.receiver.type }
+                                                                                        : e.method === "spliceInsert"
+                                                                                            ? {
+                                                                                                argTypes: [F64, F64, e.receiver.type],
+                                                                                                result: e.receiver.type,
+                                                                                            }
+                                                                                            : e.method === "flatCopy" || e.method === "flatOne"
+                                                                                                ? { argTypes: [e.type], result: e.type }
+                                                                                                : e.method === "shift"
+                                                                                                    ? { argTypes: [], result: e.type } // union-checked below
+                                                                                                    : { argTypes: [], result: F64 }; // length
+                if ((e.method === "sortPrimitive" || e.method === "toSortedPrimitive") &&
+                    elem.kind !== "string" &&
+                    elem.kind !== "f64" &&
+                    elem.kind !== "bool") {
+                    err(`arrIntrinsic ${e.method} requires primitive elements, got ${elem.kind}`, e.loc);
+                }
                 if (e.method === "getNumber" && elem.kind !== "f64") {
                     err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
                 }
-                if (e.method === "indexEq" && elem.kind !== "f64" && elem.kind !== "bool" && elem.kind !== "string") {
+                if (e.method === "indexEq" &&
+                    elem.kind !== "f64" &&
+                    elem.kind !== "bool" &&
+                    elem.kind !== "string") {
                     err(`arrIntrinsic indexEq requires primitive elements, got ${elem.kind}`, e.loc);
                 }
                 if (e.method === "flatCopy" && !typeEquals(e.type, e.receiver.type)) {
@@ -3416,7 +2147,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     err("arrIntrinsic flatOne result must match the nested array type", e.loc);
                 }
                 if (e.method === "join" &&
-                    elem.kind !== "f64" && elem.kind !== "string" && elem.kind !== "bool" &&
+                    elem.kind !== "f64" &&
+                    elem.kind !== "string" &&
+                    elem.kind !== "bool" &&
                     !(elem.kind === "union" &&
                         (unions
                             .get(elem.unionId)
@@ -3429,11 +2162,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     // 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") && !(elem.kind === "dyn" && e.type.kind === "dyn")) {
+                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") ||
-                        !(elem.kind === "union" ? typeEquals(elem, e.type) : rdef.arms.some((arm) => typeEquals(arm, elem)))) {
+                        !(elem.kind === "union"
+                            ? typeEquals(elem, e.type)
+                            : rdef.arms.some((arm) => typeEquals(arm, elem)))) {
                         err(`arrIntrinsic ${e.method} result must be the elem|undefined union`, e.loc);
                     }
                 }
@@ -3523,13 +2259,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     }
                     break;
                 }
-                if (e.method === "valueSet" && !isSupportedSetElem(value, value.kind === "union" ? unions.get(value.unionId)?.arms : undefined)) {
+                if (e.method === "valueSet" &&
+                    !isSupportedSetElem(value, value.kind === "union" ? unions.get(value.unionId)?.arms : undefined)) {
                     err(`mapIntrinsic valueSet element kind ${value.kind} (frontend must fence)`, e.loc);
                 }
                 const sig = e.method === "clone"
                     ? { argTypes: [], result: e.receiver.type }
                     : e.method === "keySet" || e.method === "valueSet"
-                        ? { argTypes: [], result: { kind: "set", elem: e.method === "keySet" ? key : value } }
+                        ? {
+                            argTypes: [],
+                            result: { kind: "set", elem: e.method === "keySet" ? key : value },
+                        }
                         : e.method === "set"
                             ? { argTypes: [key, value], result: VOID }
                             : e.method === "has" || e.method === "delete"
@@ -3824,7 +2564,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 checkExpr(e.value);
                 if (e.kind === "upcast" && e.type.kind === "classval" && e.value.type.kind === "classval") {
                     const [sub, sup] = [e.value.type.className, e.type.className];
-                    if (!isStrictSubclass(sub, sup)) {
+                    if (!isPhysicalSubclass(sub, sup)) {
                         err(`upcast: "${sub}" does not extend "${sup}"`, e.loc);
                         break;
                     }
@@ -3929,7 +2669,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // 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)
+                    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);
@@ -4120,12 +2861,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // 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" && (() => {
-                        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 === "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);
@@ -4336,7 +3079,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 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))) {
+                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;
@@ -4414,7 +3158,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 checkExpr(e.value);
                 expectType(e.value, { kind: "caught" }, "caughtNarrow operand");
                 const t = e.type;
-                const ok = t.kind === "f64" || t.kind === "bool" || t.kind === "string" ||
+                const ok = t.kind === "f64" ||
+                    t.kind === "bool" ||
+                    t.kind === "string" ||
                     (t.kind === "object" && hierarchy.has(t.className));
                 if (!ok) {
                     err(`caughtNarrow to ${t.kind === "object" ? `non-hierarchy class "${t.className}"` : t.kind}`, e.loc);
@@ -4502,11 +3248,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // 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)) ||
-                    (t.kind === "union" && !!resultUnion && (() => {
-                        const source = unions.get(t.unionId);
-                        return !!source && unionWideningTags(source.arms, resultUnion.arms) !== null;
-                    })());
+                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")) {
@@ -4675,6 +3424,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             err(`${e.name} must be void`, e.loc);
     }
     function checkLibCall(e) {
+        if (e.fn === "atomics.op" &&
+            (e.args[0]?.type.kind !== "bytes" ||
+                !["u8", "i8", "u16", "i16", "u32", "i32"].includes(e.args[0].type.elem))) {
+            errors.push({ message: "integer Atomics require an integer typed array", loc: e.loc });
+        }
+        if (e.fn === "worker.new" && !workers)
+            errors.push({ message: "Worker construction requires worker execution mode", loc: e.loc });
         const sig = LIB_FN_SIGS[e.fn];
         if (!sig) {
             err(`libCall of unknown library function "${e.fn}"`, e.loc);
@@ -4684,25 +3440,32 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         // 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" ||
+        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 === "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 === "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 === "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.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) {
+        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) => {
@@ -4725,7 +3488,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             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") {
+        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)
@@ -4748,7 +3516,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
     }
     function checkLibValueCall(e) {
-        if (e.fn === "fileHandle.read" || e.fn === "fileHandle.writeBytes" || e.fn === "fileHandle.writeStr" || e.fn === "fileHandle.readv" || e.fn === "fileHandle.writev") {
+        if (e.fn === "fileHandle.read" ||
+            e.fn === "fileHandle.writeBytes" ||
+            e.fn === "fileHandle.writeStr" ||
+            e.fn === "fileHandle.readv" ||
+            e.fn === "fileHandle.writev") {
             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" || e.fn === "fileHandle.readv" ? "bytesRead" : "bytesWritten";
@@ -4756,8 +3528,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             const payload = e.args[1]?.type;
             const count = shape ? recordValidation.get(shape.id)?.fields.get(countName) : undefined;
             const buffer = shape ? recordValidation.get(shape.id)?.fields.get(payloadName) : undefined;
-            const ok = shape !== undefined && !shape.tuple && shape.indexValue === undefined && shape.fields.length === 2 &&
-                count?.kind === "f64" && payload !== undefined && buffer !== undefined &&
+            const ok = shape !== undefined &&
+                !shape.tuple &&
+                shape.indexValue === undefined &&
+                shape.fields.length === 2 &&
+                count?.kind === "f64" &&
+                payload !== undefined &&
+                buffer !== undefined &&
                 typeEquals(buffer, payload);
             if (!ok) {
                 err(`libCall ${e.fn} must return a promise of { ${countName}: number, ${payloadName} }`, e.loc);
@@ -4787,8 +3564,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             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)))) {
+                (!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;
@@ -4864,7 +3640,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
         if (e.fn === "http2.serverOnSessionError") {
             const cbT = e.args[1]?.type;
-            const ok = cbT?.kind === "func" && cbT.ret.kind === "void" &&
+            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")) &&
@@ -4937,16 +3714,24 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             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" ||
+        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
+            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) {
@@ -4982,7 +3767,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
-        if (e.fn === "http.serverOnUpgrade" || e.fn === "http.clientOnUpgrade" ||
+        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
@@ -5019,8 +3805,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             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");
+                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);
@@ -5033,13 +3822,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // 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";
+            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";
+                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);
@@ -5054,7 +3850,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             if (e.fn === "http.requestConnCb") {
                 const cbT = e.args[6]?.type;
-                const ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1 &&
+                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);
@@ -5075,7 +3873,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
         if (e.fn === "http.resSocket") {
             const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-            const ok = def && def.arms.length === 2 &&
+            const ok = def &&
+                def.arms.length === 2 &&
                 def.arms.some((a) => a.kind === "netSocket") &&
                 def.arms.some((a) => a.kind === "nullT");
             if (!ok)
@@ -5084,14 +3883,18 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
         if (e.fn === "http.reqH2Stream") {
             const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
-            const ok = def && def.arms.length === 2 &&
+            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") {
+        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 &&
@@ -5105,24 +3908,30 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
         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" &&
+            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" ||
+        if (e.fn === "net.createServerCb" ||
+            e.fn === "net.serverOnConnection" ||
             e.fn === "net.serverOnSecureConnection" ||
-            e.fn === "http.serverSetTimeoutCb" || e.fn === "http.serverOnTimeout" ||
+            e.fn === "http.serverSetTimeoutCb" ||
+            e.fn === "http.serverOnTimeout" ||
             e.fn === "http.clientOnSocket" ||
-            e.fn === "net.sockOnData" || e.fn === "net.serverOnError" ||
+            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;
+            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];
@@ -5147,15 +3956,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // (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 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));
+                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);
@@ -5215,20 +4029,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         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") {
+        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"));
+                    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) {
@@ -5258,7 +4078,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                         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" ||
+                            def.arms.every((a) => a.kind === "nullT" ||
+                                a.kind === "undefinedT" ||
                                 (a.kind === "object" && a.className === "%Error"));
                 }
             }
@@ -5273,9 +4094,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             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";
+                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);
             }
@@ -5286,9 +4110,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             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";
+                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);
             }
@@ -5299,7 +4126,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // 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.kind === "promise"
+                    ? e.type.inner
+                    : undefined
                 : e.type;
             const shape = result?.kind === "array" && result.elem.kind === "record"
                 ? records.get(result.elem.shapeId)
@@ -5308,9 +4137,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 !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";
+                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);
             }
@@ -5322,12 +4154,28 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // 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;
+            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");
+            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);
             }
@@ -5341,12 +4189,22 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // 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");
+            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);
             }
@@ -5357,14 +4215,18 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     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") {
+            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 ||
+                    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);
@@ -5382,7 +4244,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
         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")
+            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") {
@@ -5434,8 +4299,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 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") {
+        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).
@@ -5544,7 +4411,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             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") &&
+            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");
@@ -5581,10 +4449,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             // 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" ||
+        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
@@ -5606,7 +4481,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
-        if (e.fn === "error.domCode" || e.fn === "error.domHasCause" || e.fn === "error.domCause" || e.fn === "error.domClone") {
+        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];
@@ -5664,12 +4542,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         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" ||
+        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
@@ -5772,10 +4657,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 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" ||
+            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);
@@ -5790,11 +4679,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             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");
+                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;
@@ -5813,9 +4706,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibEmitterCall(e, result) {
-        if ((e.fn.startsWith("emitter.") || e.fn === "stream.onDyn") && e.fn !== "emitter.setDefaultMax" &&
+        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") {
+            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.
@@ -5841,20 +4736,28 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 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" ||
+            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);
                 }
                 // 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") {
+                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") {
+                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);
                 }
                 return true;
@@ -5894,9 +4797,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     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.countDyn" || e.fn === "emitter.emitError") {
+            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);
                 }
@@ -5933,7 +4841,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // reads), which matches exactly the undefined arm.
                 const jsonOk = (t) => isJsonSafeType(t, (id) => records.get(id), (id) => unions.get(id));
                 const undefArmedOk = e.type.kind === "union" &&
-                    (unions.get(e.type.unionId)?.arms.every((a) => a.kind === "undefinedT" ||
+                    (unions
+                        .get(e.type.unionId)
+                        ?.arms.every((a) => a.kind === "undefinedT" ||
                         jsonOk(a) ||
                         isDynTypedRefType(a) ||
                         DYN_HANDLE_KINDS.has(a.kind)) ??
@@ -5951,7 +4861,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // 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 (!canDynCheckTo(e.type, (id) => records.get(id), (id) => unions.get(id)) && !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;
@@ -5992,7 +4908,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // The undefined next-channel has no C value form: such yields are
                 // void-typed (statement position only — the frontend fences reads).
                 if (e.captureCompletion) {
-                    if (fn.async || e.type.kind !== "dyn" || !typeEquals(e.captureCompletion.returnType, fn.returnType)) {
+                    if (fn.async ||
+                        e.type.kind !== "dyn" ||
+                        !typeEquals(e.captureCompletion.returnType, fn.returnType)) {
                         err("invalid captured generator completion", e.loc);
                     }
                 }
@@ -6161,7 +5079,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 if (resolve.kind !== "func" || resolve.ret.kind !== "void") {
                     err("promiseWithResolvers resolve must be a void-returning function", e.loc);
                 }
-                else if (inner.kind === "void" ? resolve.params.length !== 0
+                else if (inner.kind === "void"
+                    ? resolve.params.length !== 0
                     : resolve.params.length !== 1 || !typeEquals(resolve.params[0], inner)) {
                     err(`promiseWithResolvers resolve param must match the promise's inner type`, e.loc);
                 }
@@ -6215,26 +5134,64 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 if (e.type.kind !== jsOpResultKind(e.op)) {
                     err(`jsOp ${e.op} must be ${jsOpResultKind(e.op)}, got ${e.type.kind}`, e.loc);
                 }
-                const named = e.op === "getProp" || e.op === "setProp" || e.op === "callMethod" || e.op === "optCallMethod" || e.op === "globalGet" ||
+                const named = e.op === "getProp" ||
+                    e.op === "setProp" ||
+                    e.op === "callMethod" ||
+                    e.op === "optCallMethod" ||
+                    e.op === "globalGet" ||
                     e.op === "callSpread"; // the spread expression's source spelling (V8's nullish text spells it)
                 if (named !== (e.name !== undefined)) {
                     err(`jsOp ${e.op} ${named ? "requires" : "forbids"} a name`, e.loc);
                 }
                 const arity = {
-                    add: 2, sub: 2, mul: 2, div: 2, mod: 2, pow: 2,
-                    lt: 2, le: 2, gt: 2, ge: 2, eq: 2, neq: 2, instanceOf: 2,
-                    neg: 1, plus: 1, truthy: 1, not: 1, typeof: 1, toStr: 1,
-                    getProp: 1, setProp: 2, getIdx: 2, setIdx: 3, globalGet: 0,
-                    undefLit: 0, nullLit: 0, iterNew: 1, defineGetter: 3, objSpread: 2,
+                    add: 2,
+                    sub: 2,
+                    mul: 2,
+                    div: 2,
+                    mod: 2,
+                    pow: 2,
+                    lt: 2,
+                    le: 2,
+                    gt: 2,
+                    ge: 2,
+                    eq: 2,
+                    neq: 2,
+                    instanceOf: 2,
+                    neg: 1,
+                    plus: 1,
+                    truthy: 1,
+                    not: 1,
+                    typeof: 1,
+                    toStr: 1,
+                    getProp: 1,
+                    setProp: 2,
+                    getIdx: 2,
+                    setIdx: 3,
+                    globalGet: 0,
+                    undefLit: 0,
+                    nullLit: 0,
+                    iterNew: 1,
+                    defineGetter: 3,
+                    objSpread: 2,
                     callSpread: 3, // callee + pre array + spread source
-                    callMethod: null, optCallMethod: null, callFn: null, callFnThis: null, construct: null, // receiver/callee + any number of args
-                    objLit: null, arrLit: null, tplStrings: null, // variable length (objLit: key/value pairs; tplStrings: n cooked + n raw)
+                    callMethod: null,
+                    optCallMethod: null,
+                    callFn: null,
+                    callFnThis: null,
+                    construct: null, // receiver/callee + any number of args
+                    objLit: null,
+                    arrLit: null,
+                    tplStrings: null, // variable length (objLit: key/value pairs; tplStrings: n cooked + n raw)
                 };
                 const want = arity[e.op];
                 if (want !== null && want !== undefined && e.args.length !== want) {
                     err(`jsOp ${e.op} takes ${want} arg(s), got ${e.args.length}`, e.loc);
                 }
-                if (want === null && e.op !== "objLit" && e.op !== "arrLit" && e.op !== "tplStrings" && e.args.length < 1) {
+                if (want === null &&
+                    e.op !== "objLit" &&
+                    e.op !== "arrLit" &&
+                    e.op !== "tplStrings" &&
+                    e.args.length < 1) {
                     err(`jsOp ${e.op} needs a receiver/callee arg`, e.loc);
                 }
                 if (e.op === "callFnThis" && e.args.length < 2) {
@@ -6571,7 +5528,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 checkExpr(s.value);
                 // dyn throws are allowed: the dyn node rides the REF cell arm by
                 // reference (the JS-lane `throw err` of a dyn argument).
-                if (s.value.type.kind === "void" || s.value.type.kind === "caught" || s.value.type.kind === "date") {
+                if (s.value.type.kind === "void" ||
+                    s.value.type.kind === "caught" ||
+                    s.value.type.kind === "date") {
                     err(`throw of a ${s.value.type.kind} value`, s.loc);
                 }
                 break;