@scriptc/compiler 0.3.1 → 0.3.3

package/dist/ir/validate.js

@@ -4,7 +4,7 @@
  * 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, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, isDirentShape, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, 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";
@@ -55,6 +55,8 @@ export function validateModule(mod) {
     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.lifetimeRegions !== undefined && mod.lifetimeRegions !== true)
+        errors.push({ message: "lifetimeRegions must be true when present", loc: moduleLoc });
     if (mod.workers && mod.lib !== undefined)
         errors.push({
             message: "worker execution requires a native static executable",
@@ -359,6 +361,10 @@ export function validateModule(mod) {
         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.prototypeNames !== undefined &&
+            new Set(cls.prototypeNames).size !== cls.prototypeNames.length) {
+            errors.push({ message: `class ${cls.name}: duplicate prototype member names`, loc: cls.loc });
+        }
         if (cls.tracksOwnFields &&
             (cls.runtime ||
                 cls.fields.find((field) => field.name === DYN_CLASS_PROPERTIES)?.type.kind !== "dyn")) {
@@ -854,11 +860,11 @@ export function validateModule(mod) {
         }
     }
     for (const fn of mod.functions) {
-        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true);
+        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true, mod.lifetimeRegions === true);
     }
     return errors;
 }
-function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers) {
+function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers, lifetimeRegions) {
     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 = [
@@ -1458,6 +1464,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     allowed.add("return");
                     allowed.add("throw");
                     allowed.add("runtimeFence");
+                    allowed.add("tryCatch");
                 }
                 if (e.diverges) {
                     const last = e.stmts[e.stmts.length - 1];
@@ -1781,10 +1788,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (want)
                         expectType(a, want, `regexIntrinsic ${e.method} arg ${i}`);
                 });
-                if (e.method === "execGroups" && e.args[1]?.kind !== "numLit") {
-                    err("regexIntrinsic execGroups mask must be a numeric literal", e.loc);
-                }
-                if (e.method === "match" || e.method === "exec" || e.method === "execGroups") {
+                if ((e.method === "execGroups" || e.method === "execSpans" || e.method === "matchGroups") &&
+                    e.args.slice(1).some((mask) => mask.kind !== "numLit")) {
+                    err(`regexIntrinsic ${e.method} masks must be numeric literals`, e.loc);
+                }
+                if (e.method === "match" ||
+                    e.method === "exec" ||
+                    e.method === "execGroups" ||
+                    e.method === "execSpans" ||
+                    e.method === "matchGroups") {
                     // 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;
@@ -1966,6 +1978,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     buffer: { argTypes: [], minArgs: 0, result: DYN },
                     setFromDyn: { argTypes: [DYN, F64], minArgs: 1, result: VOID },
                     copyWithin: { argTypes: [F64, F64, F64], minArgs: 3, result: bytesOf(recv.elem) },
+                    sortNumeric: { argTypes: [F64], minArgs: 1, result: BOOL },
+                    sortCompare: { argTypes: e.args[0] ? [e.args[0].type] : [], minArgs: 1, result: VOID },
                     equals: { argTypes: [BYTES_U8], minArgs: 1, result: BOOL },
                     compareBuf: { argTypes: [BYTES_U8, F64, F64, F64, F64], minArgs: 1, result: F64 },
                     // [needle, align, byteOffset?] — an OMITTED byteOffset is Node's
@@ -2054,6 +2068,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (want)
                         expectType(a, want, `bytesIntrinsic ${e.method} arg ${i}`);
                 });
+                const order = e.args[0];
+                if (e.method === "sortNumeric" &&
+                    (order?.kind !== "numLit" ||
+                        (order.value !== 0 && order.value !== 1 && order.value !== -1)))
+                    err("bytesIntrinsic sortNumeric order must be the literal 0, 1 or -1", e.loc);
+                const comparator = e.args[0]?.type;
+                if (e.method === "sortCompare" &&
+                    (e.args.length !== 1 ||
+                        comparator?.kind !== "func" ||
+                        comparator.params.length > 2 ||
+                        !comparator.params.every((param) => param.kind === "f64") ||
+                        comparator.ret.kind !== "f64"))
+                    err("bytesIntrinsic sortCompare comparator must be (number, number) => number", e.loc);
                 if (!typeEquals(e.type, sig.result)) {
                     err(`bytesIntrinsic ${e.method} result must be ${sig.result.kind}, got ${e.type.kind}`, e.loc);
                 }
@@ -2119,9 +2146,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                                                                                 : e.method === "shift"
                                                                                                     ? { argTypes: [], result: e.type } // union-checked below
                                                                                                     : e.method === "sortValues"
-                                                                                                        ? { argTypes: [F64, null], result: VOID }
+                                                                                                        ? {
+                                                                                                            argTypes: [F64, null, F64, null],
+                                                                                                            result: VOID,
+                                                                                                        }
                                                                                                         : e.method === "sortDense"
-                                                                                                            ? { argTypes: [null, BOOL], result: BOOL }
+                                                                                                            ? {
+                                                                                                                argTypes: [null, BOOL, F64, null],
+                                                                                                                result: BOOL,
+                                                                                                            }
                                                                                                             : { argTypes: [], result: F64 }; // length
                 if ((e.method === "sortPrimitive" || e.method === "toSortedPrimitive") &&
                     elem.kind !== "string" &&
@@ -2142,6 +2175,25 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                         err(`arrIntrinsic ${e.method} comparator must be (elem, elem) => number`, e.loc);
                     if (e.method === "sortDense" && e.args[1]?.kind !== "boolLit")
                         err("arrIntrinsic sortDense owned flag must be a boolean literal", e.loc);
+                    // A recognized comparator's key order: [order] for numbers,
+                    // [order, key reader] for record and class elements.
+                    const order = e.args[2];
+                    if (order) {
+                        if (order.kind !== "numLit" || (order.value !== 1 && order.value !== -1))
+                            err(`arrIntrinsic ${e.method} key order must be the literal 1 or -1`, e.loc);
+                        const key = e.args[3]?.type;
+                        if (elem.kind === "f64"
+                            ? key !== undefined
+                            : elem.kind !== "record" && elem.kind !== "object")
+                            err(`arrIntrinsic ${e.method} key order on ${elem.kind} elements`, e.loc);
+                        if (elem.kind !== "f64" &&
+                            (!key ||
+                                key.kind !== "func" ||
+                                key.params.length !== 1 ||
+                                !typeEquals(key.params[0], elem) ||
+                                key.ret.kind !== "f64"))
+                            err(`arrIntrinsic ${e.method} key reader must be (elem) => number`, e.loc);
+                    }
                 }
                 if (e.method === "getNumber" && elem.kind !== "f64") {
                     err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
@@ -2188,7 +2240,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // slice's indices and splice's count are optional (omitted args
                 // omitted from the IR — backends fill the defaults); everything
                 // else is exact.
-                const minArgs = e.method === "slice" ? 0 : e.method === "splice" ? 1 : sig.argTypes.length;
+                const minArgs = e.method === "slice"
+                    ? 0
+                    : e.method === "splice"
+                        ? 1
+                        : e.method === "sortValues" || e.method === "sortDense"
+                            ? 2
+                            : sig.argTypes.length;
                 if (e.args.length < minArgs || e.args.length > sig.argTypes.length) {
                     err(`arrIntrinsic ${e.method}: ${e.args.length} args, expected ${sig.argTypes.length}`, e.loc);
                 }
@@ -2294,7 +2352,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                             ? { argTypes: [F64], result: key }
                                             : e.method === "iterValue"
                                                 ? { argTypes: [F64], result: value }
-                                                : { argTypes: [], result: F64 }; // size / iterCount
+                                                : { argTypes: [], result: F64 }; // size / iterCount / iterStart
                 if (e.args.length !== sig.argTypes.length) {
                     err(`mapIntrinsic ${e.method}: ${e.args.length} args, expected ${sig.argTypes.length}`, e.loc);
                 }
@@ -2345,7 +2403,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                         ? { argTypes: [F64], result: elem }
                                         : e.method === "toArray"
                                             ? { argTypes: [], result: arrayOf(elem) }
-                                            : { argTypes: [], result: F64 }; // size / iterCount
+                                            : { argTypes: [], result: F64 }; // size / iterCount / iterStart
                 if (e.args.length !== sig.argTypes.length) {
                     err(`setIntrinsic ${e.method}: ${e.args.length} args, expected ${sig.argTypes.length}`, e.loc);
                 }
@@ -2787,25 +2845,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.fields) {
-                    if (f.drop || f.overflow)
+                    if (f.overflow)
                         checkExpr(f.value);
                     else
                         checkSlotValue(f.value);
                     if (seen.has(f.name))
                         err(`recordLit initializes field "${f.name}" twice`, e.loc);
                     seen.add(f.name);
-                    if (f.drop) {
-                        // A mapping-dropped field (the PromiseSettledResult honest
-                        // subset): evaluated, never stored — it must NOT name a
-                        // declared field (that would silently drop a real store),
-                        // and its value may be any type, void included.
-                        if (f.overflow)
-                            err(`recordLit drop entry "${f.name}" flagged overflow too`, e.loc);
-                        if (want.has(f.name)) {
-                            err(`recordLit drop entry "${f.name}" shadows a declared field of shape ${shape.id}`, e.loc);
-                        }
-                        continue;
-                    }
                     if (f.overflow) {
                         // Overflow entries exist only on index-signature shapes, name
                         // no declared field, and carry the index-value type exactly
@@ -2827,7 +2873,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     else
                         expectType(f.value, ft, `recordLit field "${f.name}"`);
                 }
-                if (e.fields.filter((f) => !f.overflow && !f.drop).length !== shape.fields.length) {
+                if (e.fields.filter((f) => !f.overflow).length !== shape.fields.length) {
                     err(`recordLit does not initialize every field of shape ${shape.id}`, e.loc);
                 }
                 break;
@@ -3397,6 +3443,24 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 err("module.tdzCheck must be void", e.loc);
             return;
         }
+        if (e.name === "region.create" ||
+            e.name === "region.enter" ||
+            e.name === "region.leave" ||
+            e.name === "region.release") {
+            if (!lifetimeRegions)
+                err(`${e.name} outside a lifetimeRegions module`, e.loc);
+            const takesId = e.name === "region.enter" || e.name === "region.release";
+            if (e.args.length !== (takesId ? 1 : 0))
+                err(`${e.name} takes ${takesId ? "one region id" : "no arguments"}`, e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "f64")
+                    err(`${e.name} id must be f64`, e.loc);
+            }
+            if (e.type.kind !== (e.name === "region.create" ? "f64" : "void"))
+                err(`${e.name} has type ${e.name === "region.create" ? "f64" : "void"}`, e.loc);
+            return;
+        }
         if (e.name === "threads.publish") {
             if (e.args.length !== 1)
                 err("threads.publish takes exactly one argument", e.loc);
@@ -3440,6 +3504,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return;
         }
+        if (e.name === "promise.allSettled" || e.name === "promise.any") {
+            if (e.args.length !== 1)
+                err(`${e.name} takes exactly one argument`, e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "array" || a.type.elem.kind !== "promise") {
+                    err(`${a.type.kind} argument to ${e.name} (needs an array of promises)`, a.loc);
+                }
+                else if (e.name === "promise.any" && !typeEquals(a.type.elem, e.type)) {
+                    err("promise.any result must be the entries' promise type", e.loc);
+                }
+            }
+            if (e.type.kind !== "promise")
+                err(`${e.name} must be promise-typed`, e.loc);
+            else if (e.name === "promise.allSettled" &&
+                (e.type.inner.kind !== "array" || e.type.inner.elem.kind !== "union")) {
+                err("promise.allSettled result must be a promise of a settled-record union array", e.loc);
+            }
+            return;
+        }
         if (e.name === "promise.reject") {
             // ONE argument: the %Error-rooted reason object (the rejection
             // payload shares the thrown-Error representation — the
@@ -3550,11 +3634,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn === "stream.pipeline" ||
             e.fn === "stream.pipelineDyn" ||
             e.fn === "sp.pipeline" ||
+            e.fn === "sp.pipelineOpts" ||
+            e.fn === "sp.pipelineOptsSignal" ||
             e.fn === "writable.write" ||
             e.fn === "writable.writeStr" ||
             e.fn === "writable.writeU" ||
             e.fn === "writable.end" ||
-            e.fn === "readable.unpipe";
+            e.fn === "readable.unpipe" ||
+            e.fn === "rl.create" ||
+            e.fn === "rl.createSignal";
         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);
         }
@@ -3631,6 +3719,23 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
+        if (e.fn === "dyn.objEntryPairs") {
+            // Result: the native [string, any][] the backend assembles from the
+            // runtime's owned pair snapshot.
+            const shape = e.type.kind === "array" && e.type.elem.kind === "record"
+                ? records.get(e.type.elem.shapeId)
+                : undefined;
+            const field = (name) => shape?.fields.find((f) => f.name === name)?.type;
+            const ok = shape !== undefined &&
+                shape.tuple === true &&
+                shape.indexValue === undefined &&
+                shape.fields.length === 2 &&
+                field("0")?.kind === "string" &&
+                field("1")?.kind === "dyn";
+            if (!ok)
+                err(`libCall dyn.objEntryPairs must return a [string, any] tuple array`, e.loc);
+            return true;
+        }
         if (e.fn === "fetch.streamFrom") {
             const t = e.args[0]?.type;
             const ok = t?.kind === "string" ||
@@ -4211,10 +4316,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
-        if (e.fn === "fs.readdirTypesSync" || e.fn === "fsp.readdirTypes") {
+        if (e.fn === "fs.readdirTypesSync" ||
+            e.fn === "fsp.readdirTypes" ||
+            e.fn === "fs.globTypesSync" ||
+            e.fn === "fsp.globTypes") {
             // Result: the interned Dirent record array — {%dtype: f64,
             // name: string, parentPath: string} rows (canonical field
-            // order; the structure lowerFsReaddirTypesCall pinned).
+            // order; the structure lowerFsReaddirTypesCall pinned). The glob
+            // forms answer the array itself.
             const result = e.fn === "fsp.readdirTypes"
                 ? e.type.kind === "promise"
                     ? e.type.inner
@@ -4223,7 +4332,23 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             const shape = result?.kind === "array" && result.elem.kind === "record"
                 ? records.get(result.elem.shapeId)
                 : undefined;
-            const ok = shape !== undefined &&
+            const ok = shape !== undefined && isDirentShape(shape);
+            if (!ok) {
+                err(`libCall ${e.fn} must return ${e.fn === "fsp.readdirTypes" ? "a promise of " : ""}the Dirent record array`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "dir.readSync" || e.fn === "dir.read") {
+            // Result: `Dirent | null` (a promise of it for dir.read) — the
+            // interned Dirent row shape readdirTypesSync uses, or null.
+            const result = e.fn === "dir.read" ? (e.type.kind === "promise" ? e.type.inner : undefined) : e.type;
+            const def = result?.kind === "union" ? unions.get(result.unionId) : undefined;
+            const row = def?.arms.find((a) => a.kind === "record");
+            const shape = row?.kind === "record" ? records.get(row.shapeId) : undefined;
+            const ok = def !== undefined &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "nullT") &&
+                shape !== undefined &&
                 !shape.tuple &&
                 shape.indexValue === undefined &&
                 shape.fields.length === 3 &&
@@ -4234,7 +4359,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 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);
+                err(`libCall ${e.fn} must return ${e.fn === "dir.read" ? "a promise of " : ""}Dirent | null`, e.loc);
             }
             return true;
         }
@@ -4526,6 +4651,31 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibSpecialCall(e) {
+        if (e.fn === "crypto.randomFillView" || e.fn === "crypto.randomFillViewRest") {
+            // The filled view is the result, at its own element type.
+            const view = e.args[0]?.type;
+            if (view?.kind !== "bytes" || !typeEquals(e.type, view)) {
+                err(`libCall ${e.fn} must return its view argument's type`, e.loc);
+            }
+            return true;
+        }
+        if (e.fn === "crypto.timingSafeEqual") {
+            if (e.args[0]?.type.kind !== "bytes" || e.args[1]?.type.kind !== "bytes")
+                err(`libCall ${e.fn} arguments must be views`, e.loc);
+        }
+        if (e.fn === "crypto.randomFillCb") {
+            if (e.args[0]?.type.kind !== "bytes")
+                err(`libCall ${e.fn} buffer must be a view`, e.loc);
+            if (e.args[4]?.type.kind !== "func")
+                err(`libCall ${e.fn} callback must be a function`, e.loc);
+        }
+        if (e.fn === "crypto.randomFillCbDyn" ||
+            e.fn === "crypto.randomIntCb" ||
+            e.fn === "crypto.generateKeyCb") {
+            const callback = e.args[e.args.length - 1]?.type;
+            if (callback?.kind !== "func")
+                err(`libCall ${e.fn} callback must be a function`, e.loc);
+        }
         if (e.fn === "global.undefRead") {
             // Always throws — the result type is whatever the declared type
             // of the undefined global mapped to (never materialized).
@@ -4557,6 +4707,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
+        if (e.fn === "error.aggregateSetErrors" || e.fn === "error.aggregateErrors") {
+            // Receiver: exactly %AggregateError (subclassing is fenced — the
+            // hidden runtime slot admits no other layout).
+            const recv = e.args[0];
+            if (!recv || recv.type.kind !== "object" || recv.type.className !== "%AggregateError") {
+                err(`libCall ${e.fn} receiver must be %AggregateError`, e.loc);
+            }
+            return true;
+        }
         if (e.fn === "error.newDom") {
             if (e.type.kind !== "object" || e.type.className !== "%DOMException") {
                 err(`libCall error.newDom must return %DOMException, got ${e.type.kind}`, e.loc);
@@ -4637,7 +4796,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn === "stream.finished" ||
             e.fn === "stream.finishedDyn" ||
             e.fn === "stream.pipeline" ||
-            e.fn === "stream.pipelineDyn") {
+            e.fn === "stream.pipelineDyn" ||
+            e.fn === "stream.addAbortSignal" ||
+            e.fn === "stream.addAbortSignalFn" ||
+            e.fn === "stream.finishedOpts" ||
+            e.fn === "stream.finishedOptsSignal") {
             // Receiver/result: stream-hierarchy objects (a class whose base
             // chain reaches a runtime stream class). Constructors have no
             // receiver — their RESULT names the class; chaining forms
@@ -4654,6 +4817,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 return false;
             };
+            if (e.fn === "stream.addAbortSignal" || e.fn === "stream.addAbortSignalFn") {
+                // [stream, signal] (the option) or [signal, stream] (the module
+                // function): the result is the stream argument's type.
+                const s = e.args[e.fn === "stream.addAbortSignal" ? 0 : 1];
+                if (!isStreamObject(s?.type) || !typeEquals(e.type, s.type)) {
+                    err(`libCall ${e.fn} must take and return a stream-hierarchy object`, e.loc);
+                }
+                return true;
+            }
             if (e.fn.endsWith(".new")) {
                 if (!isStreamObject(e.type)) {
                     err(`libCall ${e.fn} must return a stream class, got ${e.type.kind}`, e.loc);
@@ -4686,6 +4858,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     err(`libCall ${e.fn} must be void`, e.loc);
                 return true;
             }
+            if (e.fn === "stream.finishedOpts" || e.fn === "stream.finishedOptsSignal") {
+                // (recv, readable, writable, error[, signal], cb) → the cleanup
+                // closure; the callback is a func or a checked-dynamic value.
+                if (!isStreamObject(e.args[0]?.type)) {
+                    err(`libCall ${e.fn} receiver must be a stream-hierarchy object`, e.loc);
+                }
+                const cbK = e.args[e.args.length - 1]?.type.kind;
+                if (cbK !== "func" && cbK !== "dyn")
+                    err(`libCall ${e.fn} callback must be a func or dyn`, e.loc);
+                if (e.type.kind !== "func") {
+                    err(`libCall ${e.fn} must return the cleanup closure, got ${e.type.kind}`, e.loc);
+                }
+                return true;
+            }
             if (e.fn === "stream.finished" || e.fn === "stream.finishedDyn") {
                 // (recv, cb) → the cleanup closure.
                 if (!isStreamObject(e.args[0]?.type)) {
@@ -4792,6 +4978,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn !== "emitter.setDefaultMax" &&
             e.fn !== "emitter.setDefaultMaxChk" &&
             e.fn !== "emitter.getDefaultMax" &&
+            e.fn !== "emitter.errorMonitor" &&
             e.fn !== "emitter.checkListener") {
             // Receiver: an emitter-hierarchy object (the %EventEmitter class
             // itself, or a class whose base chain reaches it). emitter.new
@@ -4960,6 +5147,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
         }
     }
+    // The yield a `delegate` genResume is checking as its argument.
+    let delegatedYield = null;
     function checkAsyncExpr(e) {
         switch (e.kind) {
             case "awaitExpr": {
@@ -4991,7 +5180,13 @@ 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 (e.delegated) {
+                    if (delegatedYield !== e)
+                        err("delegated yield outside a delegate resume", e.loc);
+                    if (e.type.kind !== "void" || e.captureCompletion)
+                        err("invalid delegated yield", e.loc);
+                }
+                else if (e.captureCompletion) {
                     if (fn.async ||
                         e.type.kind !== "dyn" ||
                         !typeEquals(e.captureCompletion.returnType, fn.returnType)) {
@@ -5014,6 +5209,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     break;
                 }
                 const genT = e.gen.type;
+                if (e.mode === "delegate") {
+                    if (e.arg !== null) {
+                        if (e.arg.kind === "yieldExpr" && e.arg.delegated)
+                            delegatedYield = e.arg;
+                        else
+                            err("genResume delegate argument is not a delegated yield", e.loc);
+                        checkExpr(e.arg);
+                        delegatedYield = null;
+                    }
+                    const outer = fn.generator;
+                    if (outer === undefined || fn.async || genT.async)
+                        err("genResume delegate outside a sync generator body", e.loc);
+                    else if (genT.nextT.kind !== "undefinedT" &&
+                        genT.nextT.kind !== "dyn" &&
+                        !typeEquals(genT.nextT, outer.nextT))
+                        err(`genResume delegate into a ${typeKey(genT.nextT)} next-channel from ${typeKey(outer.nextT)}`, e.loc);
+                    if (e.type.kind !== "bool" && e.type.kind !== "record")
+                        err(`genResume delegate result ${typeKey(e.type)}`, e.loc);
+                    break;
+                }
                 if (e.arg !== null)
                     checkExpr(e.arg);
                 if (e.mode === "step" || e.mode === "value" || e.mode === "close") {
@@ -5031,7 +5246,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                         if (e.type.kind !== "void")
                             err(`genResume close result ${typeKey(e.type)}`, e.loc);
                     }
-                    else if (genT.yieldT.kind === "void" || !typeEquals(e.type, genT.yieldT)) {
+                    else if ((genT.yieldT.kind === "void" || !typeEquals(e.type, genT.yieldT)) &&
+                        (genT.retT.kind === "void" || !typeEquals(e.type, genT.retT))) {
                         err(`genResume value ${typeKey(e.type)} != yield channel ${typeKey(genT.yieldT)}`, e.loc);
                     }
                     break;