@scriptc/compiler 0.2.0 → 0.2.2

package/dist/ir/validate.js

@@ -1,5 +1,5 @@
 import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionContainerArmsOk, URL_T, VOID } from "./ir.js";
-import { BIGINT_T } from "./ir.js";
+import { BIGINT_T, 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
@@ -26,6 +26,7 @@ export const STR_INTRINSIC_SIGS = {
     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 },
@@ -40,6 +41,8 @@ export const REGEX_INTRINSIC_SIGS = {
     // VOID here is the process.envGet sentinel; the regexIntrinsic case
     // checks the union's arms.
     match: { receiver: STRING, argTypes: [REGEX], result: VOID },
+    exec: { receiver: STRING, argTypes: [REGEX], result: VOID },
+    lastIndex: { receiver: REGEX, argTypes: [], result: F64 },
     matchAll: { receiver: STRING, argTypes: [REGEX], result: arrayOf(arrayOf(STRING)) },
     matchAllInto: { receiver: STRING, argTypes: [REGEX, arrayOf(F64)], result: arrayOf(arrayOf(STRING)) },
     search: { receiver: STRING, argTypes: [REGEX], result: F64 },
@@ -60,6 +63,14 @@ export const REGEX_INTRINSIC_SIGS = {
 export const LIB_FN_SIGS = {
     "fetch.start": { argTypes: [STRING, DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseNew": { argTypes: [DYN, DYN], result: DYN },
+    "fetch.input": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "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 } },
@@ -72,6 +83,8 @@ export const LIB_FN_SIGS = {
     // Program-dependent iterable: typed arrays/bytes/string stay intact so
     // the native stream can pull lazily; checked-dynamic values are the
     // fallback. The libCall validator below checks the closed set.
+    "fetch.webIs": { argTypes: [DYN, STRING], result: BOOL },
+    "fetch.streamIs": { argTypes: [DYN], result: BOOL },
     "fetch.streamFrom": { argTypes: [null], result: DYN },
     // The chunk/result record depends on ReadableStream<T>; validated below.
     "fetch.readerRead": { argTypes: [DYN], result: VOID },
@@ -97,6 +110,7 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -121,6 +135,7 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -220,6 +235,7 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -280,11 +296,13 @@ export const LIB_FN_SIGS = {
     "str.btoa": { argTypes: [DYN], result: STRING },
     "str.b64Missing": { argTypes: [], result: STRING },
     "str.decodeUriComponent": { argTypes: [STRING], result: STRING },
+    "str.decodeUri": { argTypes: [STRING], result: STRING },
     "str.encodeUri": { argTypes: [STRING], result: STRING },
     "regexp.escape": { argTypes: [STRING], result: STRING },
     "num.toExponential": { argTypes: [F64], result: STRING },
     "num.toFixed0": { argTypes: [F64], result: STRING },
     "num.toFixed": { argTypes: [F64, F64], result: STRING },
+    "num.toStringRadix": { argTypes: [F64, DYN], result: STRING },
     "num.sameValue": { argTypes: [F64, F64], result: BOOL },
     "intl.numFormatEnUs": { argTypes: [F64], result: STRING },
     "sym.new": { argTypes: [STRING], result: SYMBOL_T },
@@ -327,6 +345,10 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -343,6 +365,7 @@ export const LIB_FN_SIGS = {
     "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
@@ -376,11 +399,16 @@ export const LIB_FN_SIGS = {
     "qs.escape": { argTypes: [STRING], result: STRING },
     "qs.unescape": { argTypes: [STRING], result: STRING },
     "util.parseArgs": { argTypes: [DYN], result: DYN },
+    "util.parseEnv": { argTypes: [DYN], 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.readvSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
+    "fs.writevSync": { argTypes: [F64, arrayOf(BYTES_U8), F64], result: F64 },
     "fs.linkSync": { argTypes: [STRING, STRING], result: VOID },
     "fs.openSync": { argTypes: [STRING, STRING], result: F64 },
     "fs.openNumericSync": { argTypes: [STRING, F64, F64], result: F64 },
@@ -856,6 +884,8 @@ export const LIB_FN_SIGS = {
     "child.disconnect": { argTypes: [CHILD_T], result: VOID },
     "child.onMessage": { argTypes: [CHILD_T, null, BOOL], result: VOID },
     "child.onDisconnect": { argTypes: [CHILD_T, null, BOOL], result: VOID },
+    "child.onSpawn": { argTypes: [CHILD_T, null], result: VOID },
+    "child.onDyn": { argTypes: [CHILD_T, STRING, DYN], result: VOID },
     "process.connected": { argTypes: [], result: BOOL },
     "process.send": { argTypes: [STRING], result: BOOL },
     "process.sendCb": { argTypes: [STRING, null], result: BOOL },
@@ -870,6 +900,7 @@ export const LIB_FN_SIGS = {
         argTypes: [STRING, arrayOf(STRING), F64, F64, F64, F64, F64, BOOL, BOOL, BOOL, arrayOf(STRING), STRING],
         result: CHILD_T,
     },
+    "cp.spawnDynamic": { argTypes: [STRING, arrayOf(STRING), DYN], result: CHILD_T },
     // The callback's func type is program-dependent (zero params, or the
     // `number | null` union / the %Error class) — the libCall case checks
     // the shape; the slot here only pins arity and the child receiver.
@@ -921,6 +952,7 @@ export const LIB_FN_SIGS = {
     "child.kill": { argTypes: [CHILD_T, STRING], result: BOOL },
     "child.killNum": { argTypes: [CHILD_T, F64], result: BOOL },
     "child.unref": { argTypes: [CHILD_T], result: VOID },
+    "child.ref": { argTypes: [CHILD_T], result: VOID },
     "spawnRes.stdout": { argTypes: [SPAWNRES_T], result: STRING },
     "spawnRes.stderr": { argTypes: [SPAWNRES_T], result: STRING },
     "crypto.randomUUID": { argTypes: [], result: STRING },
@@ -928,6 +960,7 @@ export const LIB_FN_SIGS = {
     "crypto.randomBytes": { argTypes: [F64], result: BYTES_U8 },
     "crypto.hashDigestStr": { argTypes: [STRING, STRING, STRING], result: STRING },
     "crypto.hashDigestBytes": { argTypes: [STRING, BYTES_U8, STRING], result: STRING },
+    "crypto.native": { argTypes: [], result: DYN },
     "crypto.hashNew": { argTypes: [STRING], result: CRYPTOHASH_T },
     "crypto.hmacNewStr": { argTypes: [STRING, STRING], result: CRYPTOHMAC_T },
     "crypto.hmacNewBytes": { argTypes: [STRING, BYTES_U8], result: CRYPTOHMAC_T },
@@ -947,12 +980,17 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1025,6 +1063,12 @@ export const LIB_FN_SIGS = {
     "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.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 } },
@@ -1051,6 +1095,7 @@ export const LIB_FN_SIGS = {
     "process.cwd": { argTypes: [], result: STRING },
     "process.pid": { argTypes: [], result: F64 },
     "dyn.this": { argTypes: [], result: DYN },
+    "dyn.generatorThis": { argTypes: [], result: DYN },
     "process.getuid": { argTypes: [], result: F64 },
     "process.getgid": { argTypes: [], result: F64 },
     "process.execPath": { argTypes: [], result: STRING },
@@ -1059,6 +1104,8 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1075,6 +1122,7 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1083,9 +1131,11 @@ export const LIB_FN_SIGS = {
     "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
@@ -1098,6 +1148,7 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1120,6 +1171,12 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1144,21 +1201,36 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1171,6 +1243,7 @@ export const LIB_FN_SIGS = {
     "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
@@ -1258,6 +1331,8 @@ export const LIB_FN_SIGS = {
     "readable.pushDyn": { argTypes: [null, DYN], result: BOOL },
     "readable.unshift": { argTypes: [null, BYTES_U8], result: VOID },
     "readable.unshiftStr": { argTypes: [null, STRING], result: VOID },
+    "stream.onDyn": { argTypes: [null, STRING, DYN, BOOL, BOOL], result: VOID },
+    "readable.readDyn": { argTypes: [null, DYN], result: DYN },
     "readable.read": { argTypes: [null, F64], result: VOID },
     "readable.pause": { argTypes: [null], result: VOID },
     "readable.setEncoding": { argTypes: [null, STRING], result: VOID },
@@ -1437,7 +1512,18 @@ export const LIB_FN_SIGS = {
     "date.parseGetTime": { argTypes: [STRING], result: F64 },
     "date.utc": { argTypes: [F64, F64, F64, F64, F64, F64, F64], result: F64 },
     "text.decode": { argTypes: [BYTES_U8], result: STRING },
+    "bytes.bufferSource": { argTypes: [DYN], result: BYTES_U8 },
+    "text.decodeBufferSource": { argTypes: [DYN], result: STRING },
+    "text.decodeOptions": { argTypes: [BYTES_U8, BOOL, BOOL], result: STRING },
+    "text.decodeStream": { argTypes: [DYN, BYTES_U8, F64, BOOL, BOOL, BOOL], result: STRING },
+    "text.decodeLegacyOptions": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: STRING },
     "text.decodeLegacy": { argTypes: [BYTES_U8, F64], result: STRING },
+    "text.decoderEncoding": { argTypes: [DYN], result: F64 },
+    "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 },
@@ -1695,15 +1781,38 @@ export function validateModule(mod) {
                 errors.push({ message: `class ${cls.name}: invalid local base capture`, loc: cls.loc });
             }
         }
+        if (cls.baseValueGlobal !== undefined) {
+            const global = mod.globals?.find((global) => global.id === cls.baseValueGlobal);
+            if (cls.localBaseCapture !== undefined || !cls.base || global?.type.kind !== "classval" || global.type.className !== cls.base) {
+                errors.push({ message: `class ${cls.name}: invalid computed base global`, loc: cls.loc });
+            }
+        }
         if (cls.jsLength !== undefined && (!Number.isSafeInteger(cls.jsLength) || cls.jsLength < 0)) {
             errors.push({ message: `class ${cls.name}: invalid constructor length`, loc: cls.loc });
         }
+        if (cls.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 (cls.instancePrototypeHelper !== undefined) {
+            const helper = functionsByName.get(cls.instancePrototypeHelper);
+            const receiver = helper?.params[0]?.type;
+            if (!helper || helper.params.length !== 1 || receiver?.kind !== "object" || receiver.className !== cls.name ||
+                helper.returnType.kind !== "dyn" || helper.captures !== undefined || helper.classCaptures !== undefined) {
+                errors.push({ message: `class ${cls.name}: instance prototype helper must be a noncapturing (instance) => dyn function`, loc: cls.loc });
+            }
+        }
+        for (const symbol of cls.symbolFields ?? []) {
+            const global = mod.globals?.find((global) => global.id === symbol.globalId);
+            if (global?.type.kind !== "symbol" || !cls.fields.some((field) => field.name === symbol.field)) {
+                errors.push({ message: `class ${cls.name}: invalid symbol field metadata`, loc: cls.loc });
+            }
+        }
         const seen = new Set();
         for (const f of cls.fields) {
             if (seen.has(f.name)) {
@@ -1746,7 +1855,7 @@ 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) {
+        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]);
@@ -2113,9 +2222,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     if (isUnitType(fn.returnType)) {
         err(`return type is bare unit type ${fn.returnType.kind}`, fn.loc);
     }
-    // Caught (catch-binding) values are local-only by construction: they can
-    // never be parameters, returns, or captures (the frontend fences every
-    // escape; a caught anywhere else is frontend breakage).
+    // Exception snapshots may be captured, but are never public parameters
+    // or return values. Their payload crosses those boundaries explicitly.
     if (fn.returnType.kind === "caught")
         err("return type is caught", fn.loc);
     for (const p of fn.params) {
@@ -2133,8 +2241,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             err(`capture local "${c.localId}" is not boxed`, fn.loc);
         else if (!typeEquals(local.type, c.type))
             err(`capture local "${c.localId}" has the wrong type`, fn.loc);
-        if (c.type.kind === "caught")
-            err(`capture "${c.name}" is caught-typed`, fn.loc);
     }
     if (fn.classCaptures !== undefined) {
         const self = fn.params[0];
@@ -2838,7 +2944,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`toString of unknown union ${e.operand.type.unionId}`, e.loc);
                     }
                     else if (!def.arms.every((a) => a.kind === "undefinedT" || a.kind === "nullT" ||
-                        a.kind === "string" || a.kind === "f64" || a.kind === "bool" ||
+                        a.kind === "string" || a.kind === "f64" || a.kind === "bigint" || a.kind === "bool" ||
                         (a.kind === "bytes" && a.elem === "u8"))) {
                         err("toString union operand has a non-stringable arm (frontend must fence)", e.loc);
                     }
@@ -2908,7 +3014,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     if (want)
                         expectType(a, want, `regexIntrinsic ${e.method} arg ${i}`);
                 });
-                if (e.method === "match") {
+                if (e.method === "match" || e.method === "exec") {
                     // The `string[] | null` union (program-dependent id) — checked
                     // by arms, like the libCall case checks process.envGet.
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
@@ -4010,6 +4116,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             case "dynCall": {
                 checkExpr(e.callee);
+                if (e.calleeNameValue !== undefined) {
+                    checkExpr(e.calleeNameValue);
+                    expectType(e.calleeNameValue, STRING, "dynCall callee name");
+                }
                 if (e.receiver !== undefined) {
                     checkExpr(e.receiver);
                     expectType(e.receiver, DYN, "dynCall receiver");
@@ -4041,6 +4151,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             case "dynInvoke": {
                 checkExpr(e.recv);
+                if (e.calleeNameValue !== undefined) {
+                    checkExpr(e.calleeNameValue);
+                    expectType(e.calleeNameValue, STRING, "dynInvoke callee name");
+                }
                 expectType(e.recv, DYN, "dynInvoke receiver");
                 if (e.type.kind !== "dyn")
                     err(`dynInvoke must be dyn-typed, got ${e.type.kind}`, e.loc);
@@ -4508,7 +4622,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             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.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)
@@ -4531,18 +4645,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         }
     }
     function checkLibValueCall(e) {
-        if (e.fn === "fileHandle.read" || e.fn === "fileHandle.writeBytes" || e.fn === "fileHandle.writeStr") {
+        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" ? "bytesRead" : "bytesWritten";
+            const countName = e.fn === "fileHandle.read" || e.fn === "fileHandle.readv" ? "bytesRead" : "bytesWritten";
+            const payloadName = e.fn === "fileHandle.readv" || e.fn === "fileHandle.writev" ? "buffers" : "buffer";
             const payload = e.args[1]?.type;
             const count = shape?.fields.find((f) => f.name === countName);
-            const buffer = shape?.fields.find((f) => f.name === "buffer");
+            const buffer = shape?.fields.find((f) => f.name === payloadName);
             const ok = shape !== undefined && !shape.tuple && shape.indexValue === undefined && shape.fields.length === 2 &&
                 count?.type.kind === "f64" && payload !== undefined && buffer !== undefined &&
                 typeEquals(buffer.type, payload);
             if (!ok) {
-                err(`libCall ${e.fn} must return a promise of { ${countName}: number, buffer }`, e.loc);
+                err(`libCall ${e.fn} must return a promise of { ${countName}: number, ${payloadName} }`, e.loc);
             }
             return true;
         }
@@ -5162,6 +5277,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
             }
         }
+        if (e.fn === "child.onSpawn") {
+            const cb = e.args[1];
+            if (!cb || cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void")
+                err("child.onSpawn callback must be () => void", e.loc);
+        }
         if (e.fn === "child.onExit" || e.fn === "child.onClose" || e.fn === "child.onError") {
             // The listener: a closure with no params, or exactly the
             // supported parameter shapes per event — exit takes (code:
@@ -5590,7 +5710,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         return false;
     }
     function checkLibEmitterCall(e, result) {
-        if (e.fn.startsWith("emitter.") && 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") {
             // Receiver: an emitter-hierarchy object (the %EventEmitter class
@@ -5619,7 +5739,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             // The chaining forms return the receiver's own static class.
             if (e.fn === "emitter.on" || e.fn === "emitter.off" ||
-                e.fn === "emitter.onDyn" || e.fn === "emitter.onFlex" || e.fn === "emitter.offDyn" ||
+                e.fn === "emitter.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") {