@scriptc/compiler 0.2.0 → 0.2.1

package/dist/frontend/lowering/lower-builtins.js

@@ -7,6 +7,7 @@ import { InternalCompilerError } from "../../errors.js";
 import { builtinModules } from "node:module";
 import { dirname, isAbsolute, resolve } from "node:path";
 import * as ts from "../ts7/adapter.js";
+import { lowerCheckedPredicateValue } from "./lower-builtin-values.js";
 import { PoisonError, dynUndefinedExpr, ladderFenceExpr, nodeThrowExpr, own } from "./lowerer.js";
 import { canonicalBuiltinModule, isCreateRequireBinding7, isJsSourceFile, isNodeEsmFile, locOf, npmStaticDepSf7, requireSpecOf, resolveImport } from "../program.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
@@ -480,7 +481,7 @@ export function createRequireProgramModuleOf(lowerer, expr) {
     const cr = createRequireSpecOf(lowerer, call);
     if (cr === null || cr.spec === null || canonicalBuiltinModule(cr.spec) !== null)
         return null;
-    const dep = resolveImport(lowerer.program, cr.baseFile, cr.spec) ??
+    const dep = resolveImport(lowerer.program, cr.baseFile, cr.spec, "require") ??
         npmStaticDepSf7(lowerer.program, cr.baseFile, cr.spec, "require");
     if (dep === null || dep.fileName.endsWith(".json"))
         return null;
@@ -1161,6 +1162,9 @@ export function lowerFsToUnixTimestampCall(lowerer, expr, bi, loc) {
  * after every validation passes, exactly Node's order. Null when this
  * is not a claimed member/shape (the table or fence path stands). */
 export function lowerFsLadderCall(lowerer, expr, bi, loc) {
+    if (bi.module === "fs" && bi.member !== "rename" && builtinModuleFnOf(lowerer, bi.module, bi.member)?.fn === "fs.callbackCall") {
+        return lowerer.lowerBuiltinModuleCall(expr, bi, { fn: "fs.callbackCall", params: [], result: DYN }, loc);
+    }
     if (bi.module !== "fs" && bi.module !== "fs/promises")
         return null;
     if (!isJsSourceFile(expr.getSourceFile()))
@@ -1410,6 +1414,12 @@ function lowerZlibModuleCall(lowerer, expr, bi, loc) {
 }
 export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     const name = expr.expression.getText();
+    if (fn.fn === "fs.callbackCall" && bi.member !== "rename") {
+        if (expr.arguments.some(ts.isSpreadElement))
+            lowerer.noLowering("filesystem callback call with spread arguments", expr);
+        const args = { kind: "dynArrLit", elems: expr.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
+        return { kind: "libCall", fn: "fs.callbackCall", args: [{ kind: "strLit", value: bi.member, type: STRING, loc }, args], type: DYN, loc };
+    }
     // Numeric open flags are interpreted symbolically at the call site. The
     // O_* bit values differ between Darwin and Linux, so emit a stable mask
     // and let the target runtime select its own native constants.
@@ -2318,15 +2328,20 @@ export function lowerBuiltinModuleCall(lowerer, expr, bi, fn, loc) {
     }
     return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
 }
-/** Reflect.apply(target, thisArg, argsList) where the TARGET is a builtin
+/** Reflect.ownKeys uses native computed-key reflection. Reflect.apply(target,
+   * thisArg, argsList) where the TARGET is a builtin
    * rest-parameter table fn (path.join / path.resolve — test/common
    * fixtures.js's fixturesPath forwards its rest args exactly this way):
    * the packed libCall over a validated string[] extraction of argsList.
    * The builtins ignore the receiver, so thisArg must be an effect-free
    * spelling (`this`, an identifier, a unit literal) whose dropped
    * evaluation is unobservable; every other Reflect.apply keeps the
-   * fence. Null when this isn't a Reflect.apply call. */
-export function lowerReflectApplyCall(lowerer, call, access) {
+   * fence. Null when this isn't a supported Reflect call. */
+export function lowerReflectCall(lowerer, call, access) {
+    if (!call.questionDotToken && !access.questionDotToken && lowerer.stdlibGlobalMember(access, "Reflect") === "ownKeys" &&
+        call.arguments.length === 1 && !ts.isSpreadElement(call.arguments[0])) {
+        return { kind: "libCall", fn: "dyn.ownKeys", args: [lowerer.lowerExprExpecting(call.arguments[0], DYN)], type: DYN, loc: locOf(call) };
+    }
     if (call.questionDotToken)
         return null;
     if (lowerer.stdlibGlobalMember(access, "Reflect") !== "apply")
@@ -2340,7 +2355,10 @@ export function lowerReflectApplyCall(lowerer, call, access) {
     const bi = ts.isPropertyAccessExpression(targetNode) ? lowerer.builtinMemberOf(targetNode) : null;
     const fn = bi ? builtinModuleFnOf(lowerer, bi.module, bi.member) : null;
     if (!fn || fn.variadicPack !== true) {
-        lowerer.noLowering(`Reflect.apply of '${targetNode.getText()}'`, targetNode, fenceHint);
+        const target = lowerer.lowerExprExpecting(targetNode, DYN);
+        const receiver = lowerer.lowerExprExpecting(call.arguments[1], DYN);
+        const argumentsList = lowerer.lowerExprExpecting(call.arguments[2], DYN);
+        return { kind: "libCall", fn: "dyn.reflectApply", args: [target, receiver, argumentsList], type: DYN, loc };
     }
     const thisNode = call.arguments[1];
     const effectFree = thisNode.kind === ts.SyntaxKind.ThisKeyword ||
@@ -2524,8 +2542,8 @@ export function lowerSpawnSyncCall(lowerer, expr, loc) {
     };
 }
 /** `spawn(command, args?, options)` → one cp.spawn / cp.spawnOpts
-   * libCall. The options argument, when present, must be an object
-   * LITERAL. Stdio accepts "ignore", "inherit", or "pipe" as the scalar,
+   * libCall. Computed options use native runtime normalization. Inline
+   * stdio accepts "ignore", "inherit", or "pipe" as the scalar,
    * or the 3-tuple whose stdin pipe becomes child.stdin, stdout/stderr
    * pipes become child.stdout/child.stderr, and output slots may also be
    * number fds. Omitting stdio uses Node's default: all three piped. The
@@ -2559,7 +2577,11 @@ export function lowerSpawnCall(lowerer, expr, loc) {
             optsNode = second;
     }
     if (optsNode !== undefined && !ts.isObjectLiteralExpression(optsNode)) {
-        lowerer.noLowering("spawn with a non-literal options argument", optsNode, "pass stdio, detached, env, cwd, windowsHide, and shell in an inline object literal");
+        return {
+            kind: "libCall", fn: "cp.spawnDynamic",
+            args: [cmd, lowerer.lowerChildArgsArg(argsNode, loc), lowerer.lowerExprExpecting(optsNode, DYN)],
+            type: CHILD_T, loc,
+        };
     }
     const emptyStr = { kind: "strLit", value: "", type: STRING, loc };
     // Per-slot stdio modes (scr_child.c: 0 ignore, 1 inherit, 2 fd) and
@@ -4312,6 +4334,18 @@ export function lowerJsonMethodCall(lowerer, call, access) {
         return { kind: "libCall", fn: "json.parseReviver", args: [text, callback], type: DYN, loc };
     }
     if (member === "stringify") {
+        const replacerNode = call.arguments[1];
+        const spaceNode = call.arguments[2];
+        const runtimeOptions = replacerNode && !jsonNullishArgument(lowerer, replacerNode) &&
+            lowerer.mapTypeOf(lowerer.typeOf(replacerNode))?.kind === "dyn" ||
+            spaceNode && !jsonNullishArgument(lowerer, spaceNode) &&
+                !ts.isNumericLiteral(spaceNode) && !ts.isStringLiteral(spaceNode) && !ts.isNoSubstitutionTemplateLiteral(spaceNode) &&
+                !(ts.isPrefixUnaryExpression(spaceNode) && ts.isNumericLiteral(spaceNode.operand));
+        if (runtimeOptions && call.arguments[0]) {
+            const args = [0, 1, 2].map((index) => call.arguments[index]
+                ? lowerer.lowerExprExpecting(call.arguments[index], DYN) : dynUndefinedExpr(loc));
+            return { kind: "libCall", fn: "json.stringifyValue", args, type: DYN, loc };
+        }
         const indent = stringifySpaceIndent(lowerer, call);
         if (call.arguments.length === 0) {
             return lowerer.wrappedUndefined(lowerer.withUndefinedArm(STRING), loc);
@@ -4516,6 +4550,12 @@ function jsonNullishArgument(lowerer, node) {
  * refuse signatures that request one until that protocol is implemented. */
 function lowerJsonCallback(lowerer, node, role) {
     const callback = lowerer.lowerExpr(node);
+    if (callback.type.kind === "dyn")
+        return callback;
+    if (callback.type.kind === "union" && lowerer.dynConvertible(callback.type) &&
+        lowerer.unions.get(callback.type.unionId)?.arms.every((arm) => isUnitType(arm) || arm.kind === "func" &&
+            arm.params.length <= 2 && (role !== "reviver" || (!arm.rest && !arm.argumentsAll))))
+        return lowerer.coerceToExpected(callback, DYN);
     if (callback.type.kind === "func" && callback.type.params.length <= 2 &&
         (role !== "reviver" || (!callback.type.rest && !callback.type.argumentsAll)) &&
         canBoxFuncIntoDyn(callback.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
@@ -4959,6 +4999,9 @@ export function lowerSearchParamsNew(lowerer, expr, loc) {
         return acc;
     }
     const init = lowerer.lowerExpr(arg);
+    if (init.type.kind === "dyn") {
+        return { kind: "libCall", fn: "sp.newChecked", args: [init], type: SEARCH_PARAMS_T, loc };
+    }
     if (init.type.kind === "string") {
         return { kind: "libCall", fn: "sp.parse", args: [init], type: SEARCH_PARAMS_T, loc };
     }
@@ -5817,7 +5860,7 @@ export function lowerChildMethodCall(lowerer, call, access) {
     if ((name === "on" || name === "once") && call.arguments.length === 2) {
         const evT = lowerer.typeOf(call.arguments[0]);
         const event = evT.isStringLiteralType() ? evT.value : null;
-        if (event !== "exit" && event !== "close" && event !== "error" && event !== "message" && event !== "disconnect") {
+        if (event !== "spawn" && event !== "exit" && event !== "close" && event !== "error" && event !== "message" && event !== "disconnect") {
             lowerer.noLowering(`child.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, call.arguments[0], '"exit", "close", "error", "message", and "disconnect" are the supported child events (as literals)');
         }
         if (!ts.isExpressionStatement(call.parent)) {
@@ -5843,7 +5886,33 @@ export function lowerChildMethodCall(lowerer, call, access) {
                 loc,
             };
         }
+        const listenerNode = stripTypeCasts(call.arguments[1]);
+        if (isJsSourceFile(listenerNode.getSourceFile()) &&
+            (ts.isArrowFunction(listenerNode) || ts.isFunctionExpression(listenerNode)) &&
+            listenerNode.parameters.some((param) => param.dotDotDotToken) &&
+            listenerNode.parameters.every((param) => !param.type) &&
+            !/@(?:param|type)\b/.test(listenerNode.getSourceFile().text.slice(listenerNode.pos, listenerNode.getStart()))) {
+            for (const param of listenerNode.parameters)
+                lowerer.checkedCallbackParams.add(param);
+        }
         const cb = lowerer.lowerExpr(call.arguments[1]);
+        if (cb.type.kind === "func" && cb.type.rest) {
+            if (!canBoxFuncIntoDyn(cb.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                lowerer.noLowering("child event rest listeners with non-representable parameters", call.arguments[1]);
+            }
+            return {
+                kind: "libCall", fn: "child.onDyn",
+                args: [receiver, { kind: "strLit", value: event, type: STRING, loc },
+                    { kind: "dynFrom", value: cb, type: DYN, loc }],
+                type: VOID, loc,
+            };
+        }
+        if (event === "spawn") {
+            if (cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void") {
+                lowerer.noLowering("spawn event listeners with parameters or a returned value", call.arguments[1]);
+            }
+            return { kind: "libCall", fn: "child.onSpawn", args: [receiver, cb], type: VOID, loc };
+        }
         if (cb.type.kind !== "func" || cb.type.params.length > (event === "error" ? 1 : 2)) {
             lowerer.unsupported("SC1090", call.arguments[1], event !== "error"
                 ? `${event} listeners with more than two parameters (use (code, signal), (code), or ())`
@@ -5918,9 +5987,9 @@ export function lowerChildMethodCall(lowerer, call, access) {
     // child.unref(): drops the child from the event loop's keep-alive set
     // (the process may exit while the child runs — Node's semantics; the
     // child is still reaped while the loop runs for other reasons).
-    if (name === "unref" && call.arguments.length === 0) {
+    if ((name === "unref" || name === "ref") && call.arguments.length === 0) {
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "child.unref", args: [receiver], type: VOID, loc };
+        return { kind: "libCall", fn: name === "ref" ? "child.ref" : "child.unref", args: [receiver], type: VOID, loc };
     }
     lowerer.noLowering(`ChildProcess.${name}`, call, "send(), connected, disconnect(), on/once(\"message\" | \"disconnect\" | \"exit\" | \"close\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are supported", lowerer.checker.getSymbolAtLocation(access.name));
 }
@@ -6259,10 +6328,10 @@ export function lowerFsConstantsProperty(lowerer, expr) {
     const bi = lowerer.builtinImportOf(expr.expression);
     if (!bi || bi.module !== "fs" || bi.member !== "constants")
         return null;
-    const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4 };
+    const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4, COPYFILE_EXCL: 1, COPYFILE_FICLONE: 2, COPYFILE_FICLONE_FORCE: 4 };
     const value = own(MODES, expr.name.text);
     if (value === undefined) {
-        lowerer.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
+        lowerer.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
     }
     return { kind: "numLit", value, type: F64, loc: locOf(expr) };
 }
@@ -7777,7 +7846,7 @@ export function lowerDateCall(lowerer, call, access) {
 export function lowerTextCodecNew(lowerer, ctor, cls) {
     const args = ctor.arguments ?? [];
     const loc = locOf(ctor);
-    let encoding = -1;
+    let encoding = { kind: "numLit", value: -1, type: F64, loc };
     let label = null;
     if (cls === "TextEncoder") {
         if (args.length !== 0)
@@ -7786,17 +7855,39 @@ export function lowerTextCodecNew(lowerer, ctor, cls) {
     else if (args.length !== 0) {
         const labelT = lowerer.typeOf(args[0]);
         const parsed = labelT.isStringLiteralType() ? staticTextDecoderEncoding(labelT.value) : null;
-        if (args.length !== 1 || parsed === null) {
-            lowerer.noLowering("new TextDecoder with runtime-valued options or an unknown label", ctor, "a recognized literal WHATWG label with default options compiles");
+        if (args.length > 2)
+            lowerer.noLowering("new TextDecoder with extra arguments", ctor);
+        if (parsed === null) {
+            encoding = { kind: "libCall", fn: "text.decoderEncoding", args: [lowerer.lowerExprExpecting(args[0], DYN)], type: F64, loc };
+        }
+        else {
+            encoding = { kind: "numLit", value: parsed.kind === "utf8" ? -1 : parsed.id, type: F64, loc };
+            label = lowerer.lowerExprExpecting(args[0], STRING);
+        }
+    }
+    const options = args[1] ? stripTypeCasts(args[1]) : null;
+    const flags = new Map();
+    for (const name of ["fatal", "ignoreBOM"])
+        flags.set(name, { kind: "boolLit", value: false, type: BOOL, loc });
+    if (options) {
+        if (!ts.isObjectLiteralExpression(options))
+            lowerer.noLowering("TextDecoder options outside an object literal", options);
+        for (const property of options.properties) {
+            if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+                !ts.isIdentifier(property.name) || !flags.has(property.name.text))
+                lowerer.noLowering("unknown TextDecoder option", property);
+            const value = ts.isPropertyAssignment(property) ? property.initializer : property.name;
+            flags.set(property.name.text, lowerer.lowerExprExpecting(value, BOOL));
         }
-        encoding = parsed.kind === "utf8" ? -1 : parsed.id;
-        label = lowerer.lowerExprExpecting(args[0], STRING);
     }
     const type = lowerer.mapTypeOf(lowerer.typeOf(ctor));
     if (type?.kind !== "record")
         lowerer.badType(ctor, lowerer.typeOf(ctor));
     const result = {
-        kind: "recordLit", fields: [{ name: `%${cls}`, value: { kind: "numLit", value: encoding, type: F64, loc } }], type, loc,
+        kind: "recordLit", fields: [{ name: `%${cls}`, value: encoding }, ...(cls === "TextDecoder" ? [
+                ...[...flags].map(([name, value]) => ({ name: `%${name}`, value })),
+                { name: "%state", value: { kind: "dynObjLit", fields: [], type: DYN, loc } },
+            ] : [])], type, loc,
     };
     return label === null || label.kind === "strLit" ? result : {
         kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: label, loc }], result, type, loc,
@@ -7814,17 +7905,32 @@ function lowerStoredTextCodecCall(lowerer, call, access) {
         return null;
     if (access.name.text !== (cls === "TextEncoder" ? "encode" : "decode"))
         return null;
-    if (call.arguments.length > 1) {
-        lowerer.noLowering(cls === "TextDecoder" ? "decode with a stream option" : "TextEncoder.encode with extra arguments", call);
+    if (call.arguments.length > (cls === "TextDecoder" ? 2 : 1)) {
+        lowerer.noLowering(`${cls}.${access.name.text} with extra arguments`, call);
     }
     const loc = locOf(call);
+    let stream = { kind: "boolLit", value: false, type: BOOL, loc };
+    if (cls === "TextDecoder" && call.arguments[1]) {
+        const options = stripTypeCasts(call.arguments[1]);
+        if (!ts.isObjectLiteralExpression(options))
+            lowerer.noLowering("TextDecoder.decode options outside an object literal", options);
+        for (const property of options.properties) {
+            if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+                !ts.isIdentifier(property.name) || property.name.text !== "stream")
+                lowerer.noLowering("unknown TextDecoder.decode option", property);
+            stream = lowerer.lowerExprExpecting(ts.isPropertyAssignment(property) ? property.initializer : property.name, BOOL);
+        }
+    }
     const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "record")
         lowerer.badType(access.expression, lowerer.typeOf(access.expression));
-    const arg = call.arguments.length === 0
+    let arg = call.arguments.length === 0
         ? cls === "TextEncoder" ? strLit("", loc)
             : { kind: "bytesNew", source: null, type: BYTES_U8, loc }
         : cls === "TextEncoder" ? lowerer.lowerExprExpecting(call.arguments[0], STRING) : lowerer.lowerExpr(call.arguments[0]);
+    if (cls === "TextDecoder" && (arg.type.kind === "dyn" || arg.type.kind === "bytes" && arg.type.elem !== "u8")) {
+        arg = { kind: "libCall", fn: "bytes.bufferSource", args: [lowerer.coerceInto(call.arguments[0], arg, DYN)], type: BYTES_U8, loc };
+    }
     if (cls === "TextDecoder" && !(arg.type.kind === "bytes" && arg.type.elem === "u8")) {
         lowerer.noLowering(`TextDecoder.decode of '${lowerer.fmt(arg.type)}' values`, call, "Uint8Array/Buffer input decodes (ArrayBuffer values have no representation)");
     }
@@ -7837,22 +7943,22 @@ function lowerStoredTextCodecCall(lowerer, call, access) {
         const input = varRef("input.0", arg.type, loc);
         const result = cls === "TextEncoder"
             ? { kind: "libCall", fn: "buffer.fromStr", args: [input, { kind: "strLit", value: "utf8", type: STRING, loc }], type: BYTES_U8, loc }
-            : {
-                kind: "ternary",
-                cond: { kind: "bin", op: "<", left: { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc }, right: { kind: "numLit", value: 0, type: F64, loc }, type: BOOL, loc },
-                then: { kind: "libCall", fn: "text.decode", args: [input], type: STRING, loc },
-                else_: { kind: "libCall", fn: "text.decodeLegacy", args: [input, { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc }], type: STRING, loc },
-                type: STRING, loc,
-            };
+            : { kind: "libCall", fn: "text.decodeStream", args: [
+                    { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%state", type: DYN, loc },
+                    input,
+                    { kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field: "%TextDecoder", type: F64, loc },
+                    ...["%fatal", "%ignoreBOM"].map((field) => ({ kind: "recordGet", obj: varRef("codec.0", recT, loc), shapeId: recT.shapeId, field, type: BOOL, loc })),
+                    varRef("stream.0", BOOL, loc),
+                ], type: STRING, loc };
         lowerer.liftedFns.push({
             name,
-            params: [{ localId: "codec.0", name: "codec", type: recT }, { localId: "input.0", name: "input", type: arg.type }],
+            params: [{ localId: "codec.0", name: "codec", type: recT }, { localId: "input.0", name: "input", type: arg.type }, { localId: "stream.0", name: "stream", type: BOOL }],
             returnType: result.type,
-            locals: [{ id: "codec.0", name: "codec", type: recT, mutable: false }, { id: "input.0", name: "input", type: arg.type, mutable: false }],
+            locals: [{ id: "codec.0", name: "codec", type: recT, mutable: false }, { id: "input.0", name: "input", type: arg.type, mutable: false }, { id: "stream.0", name: "stream", type: BOOL, mutable: false }],
             body: [{ kind: "return", value: result, loc }], loc,
         });
     }
-    return { kind: "call", callee: name, args: [receiver, arg], type: cls === "TextEncoder" ? BYTES_U8 : STRING, loc };
+    return { kind: "call", callee: name, args: [receiver, arg, stream], type: cls === "TextEncoder" ? BYTES_U8 : STRING, loc };
 }
 /** A direct construction of THE stdlib TextEncoder/TextDecoder, through
    * type-only wrappers. Name alone is never enough: a user class with the
@@ -7893,6 +7999,8 @@ export function lowerTextCodecCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const { cls, ctor: recv } = info;
+    if (cls === "TextDecoder" && ((recv.arguments?.length ?? 0) > 1 || call.arguments.length > 1))
+        return lowerStoredTextCodecCall(lowerer, call, access);
     if (!(cls === "TextDecoder" && member === "decode") && !(cls === "TextEncoder" && member === "encode")) {
         return null;
     }
@@ -7909,7 +8017,7 @@ export function lowerTextCodecCall(lowerer, call, access) {
                 ? staticTextDecoderEncoding(labelT.value)
                 : null;
         if (ctorArgs.length > 1 || encoding === null) {
-            lowerer.noLowering("new TextDecoder with runtime-valued options or an unknown label", recv, "a recognized literal WHATWG label with default options compiles");
+            return lowerStoredTextCodecCall(lowerer, call, access);
         }
         const labelEffect = ctorArgs.length === 1
             ? lowerer.lowerExprExpecting(ctorArgs[0], STRING)
@@ -7931,7 +8039,10 @@ export function lowerTextCodecCall(lowerer, call, access) {
             lowerer.noLowering("decode with a stream option", call, "streaming decode has no lowering — decode whole buffers");
         }
         const argNode = call.arguments[0];
-        const arg = lowerer.lowerExpr(argNode);
+        let arg = lowerer.lowerExpr(argNode);
+        if (arg.type.kind === "dyn" || arg.type.kind === "bytes" && arg.type.elem !== "u8") {
+            arg = { kind: "libCall", fn: "bytes.bufferSource", args: [lowerer.coerceInto(argNode, arg, DYN)], type: BYTES_U8, loc };
+        }
         if (!(arg.type.kind === "bytes" && arg.type.elem === "u8")) {
             lowerer.noLowering(`TextDecoder.decode of '${lowerer.fmt(arg.type)}' values`, argNode, "Uint8Array/Buffer input decodes (ArrayBuffer values have no representation)");
         }
@@ -8159,7 +8270,7 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
             // reads are the routed keyed ops). All-static tuples keep the
             // typed fence hint below. --dynamic only by construction: jsval
             // entries exist only there.
-            if (elems.some((e) => e.type.kind === "jsval")) {
+            if (lowerer.dynamic && elems.some((e) => e.type.kind === "jsval" || e.type.kind === "dyn")) {
                 const diagsBefore = lowerer.diags.length;
                 try {
                     const marshaled = argNode.elements.map((el, i) => lowerer.jsvalIn(elems[i], el));
@@ -8192,7 +8303,7 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
         // marshaled array (an 'any' value passes through; an `any[]` value
         // lifts per element by reference), the result staying an island
         // value the static side awaits through the island→static bridge.
-        if (entries.type.kind === "jsval" ||
+        if (entries.type.kind === "jsval" || lowerer.dynamic && entries.type.kind === "dyn" ||
             (entries.type.kind === "array" && entries.type.elem.kind === "jsval")) {
             const diagsBefore = lowerer.diags.length;
             try {
@@ -8368,11 +8479,12 @@ export function lowerPromiseStaticCall(lowerer, call, access) {
             return { kind: "intrinsic", name: "promise.resolve", args: [], type: { kind: "promise", inner: VOID }, loc };
         }
         if (resultT.inner.kind === "void") {
-            // Promise.resolve(expr) at a void-promise type: the argument's
-            // effects must still run — no statement slot exists here for
-            // them, so only effect-free spellings could drop it honestly;
-            // fence rather than model that corner.
-            lowerer.noLowering("Promise.resolve with an argument at a void-promise type", call);
+            return {
+                kind: "seqExpr",
+                stmts: [lowerer.lowerExprStatement(argNode)],
+                result: { kind: "intrinsic", name: "promise.resolve", args: [], type: resultT, loc },
+                type: resultT, loc,
+            };
         }
         if (isUnitType(resultT.inner)) {
             // A unit payload (Promise<undefined>/Promise<null>) has no
@@ -8392,6 +8504,9 @@ export function lowerNumberStaticProperty(lowerer, expr) {
     const member = lowerer.stdlibGlobalMember(expr, "Number");
     if (member === null)
         return null;
+    const predicate = own(NUMBER_STATIC_PREDICATES, member);
+    if (predicate)
+        return lowerCheckedPredicateValue(lowerer, `Number.${member}`, "number", locOf(expr), predicate);
     const value = own(NUMBER_CONSTANTS, member);
     if (value === undefined)
         return null;