@scriptc/compiler 0.1.1 → 0.1.3

package/dist/ir/validate.js

@@ -1,4 +1,5 @@
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_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, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, CHILD_T, CHILDSTREAM_T, CHILDWRITER_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DGRAMSOCK_T, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, FILEHANDLE_T, FSWATCHER_T, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, NETSERVER_T, NETSOCKET_T, PROCSTREAM_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, SEARCH_PARAMS_T, SECURECTX_T, shapeHasAccessorSlots, SPAWNRES_T, STATS_T, STRING, SYMBOL_T, TESTCTX_T, typeEquals, typeKey, unionFuncSetArmsOk, URL_T, VOID } from "./ir.js";
+import { BIGINT_T } from "./ir.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
@@ -85,6 +86,22 @@ export const LIB_FN_SIGS = {
     "dyn.toString": { argTypes: [DYN, STRING, STRING], result: STRING },
     "dyn.defineProps": { argTypes: [DYN, DYN], result: DYN },
     "dyn.typeof": { 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 },
@@ -213,6 +230,34 @@ export const LIB_FN_SIGS = {
     "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.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.protocol": { argTypes: [URL_T], result: STRING },
     "url.host": { argTypes: [URL_T], result: STRING },
@@ -684,11 +729,20 @@ export const LIB_FN_SIGS = {
     // 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.onEnd": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
+    "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 },
@@ -701,6 +755,25 @@ 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.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 },
     // 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 },
@@ -937,12 +1010,14 @@ export const LIB_FN_SIGS = {
     "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 },
@@ -1118,6 +1193,9 @@ function isBuiltinErrorObject(t) {
  * TReturn channel, so call sites see the generator type. The one place
  * 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 };
+    }
     if (fn.async)
         return { kind: "promise", inner: fn.returnType };
     if (fn.generator !== undefined) {
@@ -1132,9 +1210,6 @@ export function validateModule(mod) {
         if (functionsByName.has(fn.name)) {
             errors.push({ message: `duplicate function "${fn.name}"`, loc: fn.loc });
         }
-        if (fn.async && fn.generator !== undefined) {
-            errors.push({ message: `function "${fn.name}" is both async and a generator (async generators are fenced)`, loc: fn.loc });
-        }
         functionsByName.set(fn.name, fn);
     }
     const ffiByName = new Map();
@@ -1716,7 +1791,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     const liveDynRefEligible = (type, seen = new Set()) => {
         if (type.kind === "record" ||
             type.kind === "array" ||
-            type.kind === "bytes") {
+            type.kind === "bytes" ||
+            isDynTypedRefType(type)) {
             return true;
         }
         if (type.kind !== "union" || seen.has(type.unionId))
@@ -1936,9 +2012,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 checkExpr(e.operand);
                 if (e.operand.type.kind !== "f64" &&
                     e.operand.type.kind !== "string" &&
+                    e.operand.type.kind !== "dyn" &&
                     e.operand.type.kind !== "union" &&
                     !REF_TRUTHY_KINDS.has(e.operand.type.kind)) {
-                    err(`toBool operand must be f64|string|union|ref, got ${e.operand.type.kind}`, e.loc);
+                    err(`toBool operand must be f64|string|dyn|union|ref, got ${e.operand.type.kind}`, e.loc);
                 }
                 if (e.operand.type.kind === "union")
                     checkTruthyUnion(e.operand.type.unionId, e.loc);
@@ -4301,6 +4378,18 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
+                if (e.fn === "writer.onDrain" || e.fn === "writer.onFinish" || e.fn === "writer.onError") {
+                    const cbT = e.args[1]?.type;
+                    const maxParams = e.fn === "writer.onError" ? 1 : 0;
+                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
+                    if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
+                        const p = cbT.params[0];
+                        ok = p.kind === "object" && p.className === "%Error";
+                    }
+                    if (!ok)
+                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+                    break;
+                }
                 if (e.fn === "process.onExit" || e.fn === "process.offExit" ||
                     e.fn === "stdin.onData" || e.fn === "stdin.onError") {
                     // The listener: a void closure with no params, or exactly the
@@ -4420,14 +4509,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
-                if (e.fn === "child.stdout" || e.fn === "child.stderr") {
+                if (e.fn === "child.stdin" || e.fn === "child.stdout" || e.fn === "child.stderr") {
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+                    const handleKind = e.fn === "child.stdin" ? "childWriter" : "childStream";
                     const ok = def &&
                         def.arms.length === 2 &&
-                        def.arms.some((a) => a.kind === "childStream") &&
+                        def.arms.some((a) => a.kind === handleKind) &&
                         def.arms.some((a) => a.kind === "nullT");
                     if (!ok) {
-                        err(`libCall ${e.fn} must return the 'Readable | null' union`, e.loc);
+                        err(`libCall ${e.fn} must return the '${e.fn === "child.stdin" ? "Writable" : "Readable"} | null' union`, e.loc);
                     }
                     break;
                 }
@@ -4527,7 +4617,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 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.prop" ||
+                    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") {
@@ -4635,7 +4725,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     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.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);
                         }
@@ -4795,13 +4886,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // 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" || jsonOk(a)) ??
+                    (unions.get(e.type.unionId)?.arms.every((a) => a.kind === "undefinedT" ||
+                        jsonOk(a) ||
+                        isDynTypedRefType(a) ||
+                        DYN_HANDLE_KINDS.has(a.kind)) ??
                         false);
                 // bytes<u8> targets extract the checked-dynamic tree's bytes kind (a copy).
                 const bytesOk = e.type.kind === "bytes" && e.type.elem === "u8";
                 // The %Error root extracts the checked-dynamic tree's error encoding (the "%error"
                 // marker object caughtToDyn builds) as a fresh runtime error.
                 const errorOk = e.type.kind === "object" && e.type.className === "%Error";
+                const classOk = isDynTypedRefType(e.type);
                 // ADAPTABLE function targets unwrap or wrap the checked-dynamic tree's function
                 // kind (the checked-dynamic function boundary, ir.ts).
                 const funcOk = e.type.kind === "func" &&
@@ -4809,7 +4904,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // Runtime HANDLE targets unwrap the checked-dynamic tree's handle kind by tag (a
                 // retained reference, no copy — DYN_HANDLE_KINDS).
                 const handleOk = DYN_HANDLE_KINDS.has(e.type.kind);
-                if (!jsonOk(e.type) && !undefArmedOk && !bytesOk && !errorOk && !funcOk && !handleOk) {
+                if (!jsonOk(e.type) && !undefArmedOk && !bytesOk && !errorOk && !classOk && !funcOk && !handleOk) {
                     err(`dynCheck against non-JSON-representable type ${e.type.kind}`, e.loc);
                 }
                 break;
@@ -4888,17 +4983,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`genResume throw of a ${e.arg.type.kind} value`, e.loc);
                     }
                 }
-                // The result is the IteratorResult record { done: bool, value: V }
+                // Sync resumes return IteratorResult directly; async resumes return
+                // Promise<IteratorResult>. The record is { done: bool, value: V }
                 // with V dyn (the any/unknown channel) or an undefined-armed union.
-                if (e.type.kind !== "record") {
-                    err(`genResume result is ${e.type.kind}, not a record`, e.loc);
+                const resultT = genT.async ? (e.type.kind === "promise" ? e.type.inner : null) : e.type;
+                if (resultT?.kind !== "record") {
+                    err(`genResume result is ${typeKey(e.type)}, not ${genT.async ? "a promise of " : ""}a record`, e.loc);
                     break;
                 }
-                const rec = records.get(e.type.shapeId);
+                const rec = records.get(resultT.shapeId);
                 const doneF = rec?.fields.find((f) => f.name === "done");
                 const valueF = rec?.fields.find((f) => f.name === "value");
                 if (!rec || rec.fields.length !== 2 || doneF?.type.kind !== "bool" || valueF === undefined) {
-                    err(`genResume result record ${e.type.shapeId} is not { done: bool, value: V }`, e.loc);
+                    err(`genResume result record ${resultT.shapeId} is not { done: bool, value: V }`, e.loc);
                     break;
                 }
                 if (valueF.type.kind === "dyn")
@@ -5122,19 +5219,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     let breakableDepth = 0;
     // Labeled jump targets, innermost last: every loop/switch/labeled-block
     // enters with its labels (possibly none) so `break lbl`/`continue lbl`
-    // can resolve to an enclosing entry — and so the finally backstop can
-    // compare the TARGET's position, not just the innermost depth.
+    // can resolve to an enclosing entry.
     const labelTargets = [];
-    // Active try-with-finally regions: break/continue may not cross one, and
-    // NO jump may leave a finally BODY (the frontend fences both; this is the
-    // backstop). `return` crossing a region is modeled now (the backend's
-    // pending-return path), so returns are legal in tryBody/catchBody but
-    // still rejected inside finallyBody (they would replace a pending
-    // completion). Each entry records the loop/switch depths (and the label
-    // stack length) at region entry: a break whose target is at or below
-    // them would cross the finally.
-    const finallyRegions = [];
-    let finallyBlockDepth = 0;
     function checkStmts(stmts) {
         for (const s of stmts)
             checkStmt(s);
@@ -5148,12 +5234,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         breakableDepth--;
         loopDepth--;
     }
-    /** The innermost enclosing target carrying `label`, or null — plus its
-     * index for the finally-region crossing check. */
+    /** The innermost enclosing target carrying `label`, or null. */
     function labelTargetOf(label) {
         for (let i = labelTargets.length - 1; i >= 0; i--) {
             if (labelTargets[i].labels.includes(label))
-                return { entry: labelTargets[i], index: i };
+                return labelTargets[i];
         }
         return null;
     }
@@ -5450,67 +5535,39 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`tryCatch catch binding without a catch body`, s.loc);
                     }
                 }
-                const guarded = s.finallyBody !== null;
-                if (guarded)
-                    finallyRegions.push({ loopDepth, breakableDepth, labelLen: labelTargets.length });
                 checkStmts(s.tryBody);
                 if (s.catchBody)
                     checkStmts(s.catchBody);
-                if (s.finallyBody) {
-                    finallyBlockDepth++;
+                if (s.finallyBody)
                     checkStmts(s.finallyBody);
-                    finallyBlockDepth--;
-                }
-                if (guarded)
-                    finallyRegions.pop();
                 break;
             }
             case "break": {
-                const region = finallyRegions[finallyRegions.length - 1];
                 if (s.label !== undefined) {
                     const target = labelTargetOf(s.label);
                     if (!target)
                         err(`break to unknown label "${s.label}"`, s.loc);
-                    else if (region && target.index < region.labelLen) {
-                        err(`labeled break crossing a finally block (frontend must reject)`, s.loc);
-                    }
                     break;
                 }
                 if (breakableDepth === 0)
                     err(`break outside a loop or switch`, s.loc);
-                if (region && breakableDepth <= region.breakableDepth) {
-                    err(`break crossing a finally block (frontend must reject)`, s.loc);
-                }
                 break;
             }
             case "continue": {
-                const region = finallyRegions[finallyRegions.length - 1];
                 if (s.label !== undefined) {
                     const target = labelTargetOf(s.label);
                     if (!target)
                         err(`continue to unknown label "${s.label}"`, s.loc);
-                    else if (target.entry.kind !== "loop") {
+                    else if (target.kind !== "loop") {
                         err(`continue to non-loop label "${s.label}"`, s.loc);
                     }
-                    else if (region && target.index < region.labelLen) {
-                        err(`labeled continue crossing a finally block (frontend must reject)`, s.loc);
-                    }
                     break;
                 }
                 if (loopDepth === 0)
                     err(`continue outside a loop`, s.loc);
-                if (region && loopDepth <= region.loopDepth) {
-                    err(`continue crossing a finally block (frontend must reject)`, s.loc);
-                }
                 break;
             }
             case "return":
-                // Crossing OUT of a try/catch body guarded by a finally is modeled
-                // (the backend's pending-return path); a return inside the finally
-                // BODY itself is not (it would replace a pending completion).
-                if (finallyBlockDepth > 0) {
-                    err(`return inside a finally body (frontend must reject)`, s.loc);
-                }
                 if (s.value) {
                     checkExpr(s.value);
                     expectType(s.value, fn.returnType, "return value");