@tsonic/emitter 0.0.67 → 0.0.69

package/dist/expressions/calls/call-emitter.js

@@ -8,8 +8,10 @@ import { emitMemberAccess } from "../access.js";
 import { isLValue, getPassingModifierFromCast, isJsonSerializerCall, isGlobalJsonCall, isInstanceMemberAccess, shouldEmitFluentExtensionCall, getTypeNamespace, registerJsonAotType, needsIntCast, isPromiseChainMethod, isAsyncWrapperType, } from "./call-analysis.js";
 import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
 import { resolveImportPath } from "../../core/semantic/index.js";
+import { containsTypeParameter } from "../../core/semantic/type-resolution.js";
+import { allocateLocalName } from "../../core/format/local-names.js";
 /**
- * Wrap an expression AST with an optional argument modifier (ref/out/in/params).
+ * Wrap an expression AST with an optional argument modifier (ref/out/in).
  */
 const wrapArgModifier = (modifier, expr) => modifier
     ? { kind: "argumentModifierExpression", modifier, expression: expr }
@@ -25,6 +27,221 @@ const wrapIntCast = (needsCast, expr) => needsCast
     }
     : expr;
 const stripClrGenericArity = (typeName) => typeName.replace(/`\d+$/, "");
+const nativeArrayMutationMembers = new Set([
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice",
+    "sort",
+    "reverse",
+    "fill",
+    "copyWithin",
+]);
+const returnsMutatedArrayMember = (memberName) => memberName === "sort" ||
+    memberName === "reverse" ||
+    memberName === "fill" ||
+    memberName === "copyWithin";
+const createVarLocal = (name, initializer) => ({
+    kind: "localDeclarationStatement",
+    modifiers: [],
+    type: { kind: "varType" },
+    declarators: [{ name, initializer }],
+});
+const captureAssignableArrayTarget = (expr, context) => {
+    const [receiverAst, receiverContext] = emitExpressionAst(expr, context);
+    if (receiverAst.kind === "identifierExpression") {
+        return {
+            readExpression: receiverAst,
+            writeExpression: receiverAst,
+            setupStatements: [],
+            context: receiverContext,
+        };
+    }
+    if (receiverAst.kind === "memberAccessExpression") {
+        const objectTemp = allocateLocalName("__tsonic_arrayTarget", receiverContext);
+        const objectIdentifier = {
+            kind: "identifierExpression",
+            identifier: objectTemp.emittedName,
+        };
+        return {
+            readExpression: {
+                kind: "memberAccessExpression",
+                expression: objectIdentifier,
+                memberName: receiverAst.memberName,
+            },
+            writeExpression: {
+                kind: "memberAccessExpression",
+                expression: objectIdentifier,
+                memberName: receiverAst.memberName,
+            },
+            setupStatements: [
+                createVarLocal(objectTemp.emittedName, receiverAst.expression),
+            ],
+            context: objectTemp.context,
+        };
+    }
+    if (receiverAst.kind === "elementAccessExpression" &&
+        receiverAst.arguments.length === 1) {
+        const objectTemp = allocateLocalName("__tsonic_arrayTarget", receiverContext);
+        const indexTemp = allocateLocalName("__tsonic_arrayIndex", objectTemp.context);
+        const objectIdentifier = {
+            kind: "identifierExpression",
+            identifier: objectTemp.emittedName,
+        };
+        const indexIdentifier = {
+            kind: "identifierExpression",
+            identifier: indexTemp.emittedName,
+        };
+        return {
+            readExpression: {
+                kind: "elementAccessExpression",
+                expression: objectIdentifier,
+                arguments: [indexIdentifier],
+            },
+            writeExpression: {
+                kind: "elementAccessExpression",
+                expression: objectIdentifier,
+                arguments: [indexIdentifier],
+            },
+            setupStatements: [
+                createVarLocal(objectTemp.emittedName, receiverAst.expression),
+                createVarLocal(indexTemp.emittedName, receiverAst.arguments[0]),
+            ],
+            context: indexTemp.context,
+        };
+    }
+    return undefined;
+};
+const emitArrayMutationInteropCall = (expr, context) => {
+    if (expr.isOptional)
+        return undefined;
+    if (expr.callee.kind !== "memberAccess")
+        return undefined;
+    if (expr.callee.isComputed)
+        return undefined;
+    if (typeof expr.callee.property !== "string")
+        return undefined;
+    if (!nativeArrayMutationMembers.has(expr.callee.property))
+        return undefined;
+    if (!isLValue(expr.callee.object))
+        return undefined;
+    const binding = expr.callee.memberBinding;
+    if (!binding || binding.isExtensionMethod)
+        return undefined;
+    const receiverType = expr.callee.object.inferredType;
+    if (!receiverType || receiverType.kind !== "arrayType")
+        return undefined;
+    const captured = captureAssignableArrayTarget(expr.callee.object, context);
+    if (!captured)
+        return undefined;
+    let currentContext = captured.context;
+    const [elementTypeAst, elementTypeContext] = emitTypeAst(receiverType.elementType, currentContext);
+    currentContext = elementTypeContext;
+    const wrapperTemp = allocateLocalName("__tsonic_arrayWrapper", currentContext);
+    currentContext = wrapperTemp.context;
+    const resultTemp = allocateLocalName("__tsonic_arrayResult", currentContext);
+    currentContext = resultTemp.context;
+    const wrapperIdentifier = {
+        kind: "identifierExpression",
+        identifier: wrapperTemp.emittedName,
+    };
+    const resultIdentifier = {
+        kind: "identifierExpression",
+        identifier: resultTemp.emittedName,
+    };
+    const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
+    currentContext = argContext;
+    const mutationCall = {
+        kind: "invocationExpression",
+        expression: {
+            kind: "memberAccessExpression",
+            expression: wrapperIdentifier,
+            memberName: binding.member,
+        },
+        arguments: argAsts,
+    };
+    const mutatedArrayAst = {
+        kind: "invocationExpression",
+        expression: {
+            kind: "memberAccessExpression",
+            expression: wrapperIdentifier,
+            memberName: "toArray",
+        },
+        arguments: [],
+    };
+    let returnExpression = resultIdentifier;
+    if (expr.callee.property === "splice") {
+        returnExpression = {
+            kind: "invocationExpression",
+            expression: {
+                kind: "memberAccessExpression",
+                expression: resultIdentifier,
+                memberName: "toArray",
+            },
+            arguments: [],
+        };
+    }
+    else if (returnsMutatedArrayMember(expr.callee.property)) {
+        returnExpression = mutatedArrayAst;
+    }
+    const returnType = expr.inferredType ?? receiverType;
+    const [returnTypeAst, returnTypeContext] = emitTypeAst(returnType, currentContext);
+    currentContext = returnTypeContext;
+    const lambdaAst = {
+        kind: "lambdaExpression",
+        isAsync: false,
+        parameters: [],
+        body: {
+            kind: "blockStatement",
+            statements: [
+                ...captured.setupStatements,
+                createVarLocal(wrapperTemp.emittedName, {
+                    kind: "objectCreationExpression",
+                    type: {
+                        kind: "identifierType",
+                        name: "global::Tsonic.JSRuntime.JSArray",
+                        typeArguments: [elementTypeAst],
+                    },
+                    arguments: [captured.readExpression],
+                }),
+                createVarLocal(resultTemp.emittedName, mutationCall),
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "assignmentExpression",
+                        operatorToken: "=",
+                        left: captured.writeExpression,
+                        right: mutatedArrayAst,
+                    },
+                },
+                {
+                    kind: "returnStatement",
+                    expression: returnExpression,
+                },
+            ],
+        },
+    };
+    const delegateCastAst = {
+        kind: "castExpression",
+        type: buildDelegateType([], returnTypeAst),
+        expression: {
+            kind: "parenthesizedExpression",
+            expression: lambdaAst,
+        },
+    };
+    return [
+        wrapIntCast(needsIntCast(expr, expr.callee.property), {
+            kind: "invocationExpression",
+            expression: {
+                kind: "parenthesizedExpression",
+                expression: delegateCastAst,
+            },
+            arguments: [],
+        }),
+        currentContext,
+    ];
+};
 const emitArrayWrapperInteropCall = (expr, context) => {
     if (expr.isOptional)
         return undefined;
@@ -142,11 +359,74 @@ const callbackParameterCount = (callbackExpr) => {
     }
     return 1;
 };
+const collectBlockReturnTypes = (block) => {
+    const collectFromStatement = (statement) => {
+        switch (statement.kind) {
+            case "returnStatement":
+                return statement.expression?.inferredType
+                    ? [statement.expression.inferredType]
+                    : [];
+            case "blockStatement":
+                return statement.statements.flatMap(collectFromStatement);
+            case "ifStatement":
+                return [
+                    ...collectFromStatement(statement.thenStatement),
+                    ...(statement.elseStatement
+                        ? collectFromStatement(statement.elseStatement)
+                        : []),
+                ];
+            case "whileStatement":
+            case "forStatement":
+            case "forOfStatement":
+            case "forInStatement":
+                return collectFromStatement(statement.body);
+            case "switchStatement":
+                return statement.cases.flatMap((switchCase) => switchCase.statements.flatMap(collectFromStatement));
+            case "tryStatement":
+                return [
+                    ...statement.tryBlock.statements.flatMap(collectFromStatement),
+                    ...(statement.catchClause
+                        ? statement.catchClause.body.statements.flatMap(collectFromStatement)
+                        : []),
+                    ...(statement.finallyBlock
+                        ? statement.finallyBlock.statements.flatMap(collectFromStatement)
+                        : []),
+                ];
+            case "functionDeclaration":
+            case "classDeclaration":
+            case "interfaceDeclaration":
+            case "enumDeclaration":
+            case "typeAliasDeclaration":
+                return [];
+            default:
+                return [];
+        }
+    };
+    return block.statements.flatMap(collectFromStatement);
+};
+const getCallbackDelegateReturnType = (callbackExpr) => {
+    if ((callbackExpr.kind === "arrowFunction" ||
+        callbackExpr.kind === "functionExpression") &&
+        callbackExpr.body.kind === "blockStatement") {
+        const returnTypes = collectBlockReturnTypes(callbackExpr.body);
+        const concreteReturnTypes = returnTypes.filter((type) => !isVoidOrUnknownIrType(type));
+        if (concreteReturnTypes.length === 0) {
+            return undefined;
+        }
+        const deduped = concreteReturnTypes.filter((type, index, all) => all.findIndex((candidate) => stableIrTypeKey(candidate) === stableIrTypeKey(type)) === index);
+        if (deduped.length === 1) {
+            return deduped[0];
+        }
+        return {
+            kind: "unionType",
+            types: deduped,
+        };
+    }
+    return getCallbackReturnType(callbackExpr);
+};
 const callbackReturnsAsyncWrapper = (callbackExpr) => {
-    const callbackType = callbackExpr.inferredType;
-    return callbackType?.kind === "functionType"
-        ? isAsyncWrapperType(callbackType.returnType)
-        : false;
+    const delegateReturnType = getCallbackDelegateReturnType(callbackExpr);
+    return delegateReturnType ? isAsyncWrapperType(delegateReturnType) : false;
 };
 const buildInvocation = (expression, args) => ({
     kind: "invocationExpression",
@@ -178,32 +458,763 @@ const buildDelegateType = (parameterTypes, returnType) => {
                 typeArguments: parameterTypes,
             };
     }
-    return {
-        kind: "identifierType",
-        name: "global::System.Func",
-        typeArguments: [...parameterTypes, returnType],
-    };
+    return {
+        kind: "identifierType",
+        name: "global::System.Func",
+        typeArguments: [...parameterTypes, returnType],
+    };
+};
+const isVoidOrUnknownIrType = (type) => type === undefined ||
+    type.kind === "voidType" ||
+    type.kind === "unknownType" ||
+    (type.kind === "primitiveType" && type.name === "undefined");
+const getCallbackReturnType = (callbackExpr) => {
+    if (callbackExpr.kind === "arrowFunction" &&
+        callbackExpr.body.kind !== "blockStatement" &&
+        !isVoidOrUnknownIrType(callbackExpr.body.inferredType)) {
+        return callbackExpr.body.inferredType;
+    }
+    const declared = callbackExpr.inferredType?.kind === "functionType"
+        ? callbackExpr.inferredType.returnType
+        : undefined;
+    if (!isVoidOrUnknownIrType(declared)) {
+        return declared;
+    }
+    if (callbackExpr.kind === "arrowFunction" &&
+        callbackExpr.body.kind !== "blockStatement") {
+        return callbackExpr.body.inferredType;
+    }
+    return undefined;
+};
+const getFunctionValueSignature = (expr) => {
+    const calleeType = expr.callee.inferredType;
+    if (!calleeType || calleeType.kind !== "functionType")
+        return undefined;
+    if (expr.callee.kind === "identifier" && expr.callee.resolvedClrType) {
+        return undefined;
+    }
+    if (expr.callee.kind === "memberAccess" && expr.callee.memberBinding) {
+        return undefined;
+    }
+    return calleeType;
+};
+const emitFunctionValueCallArguments = (args, signature, expr, context) => {
+    let currentContext = context;
+    const argAsts = [];
+    const parameters = signature.parameters;
+    const extractTupleRestCandidates = (type) => {
+        if (!type)
+            return undefined;
+        if (type.kind === "tupleType") {
+            return [type.elementTypes];
+        }
+        if (type.kind !== "unionType") {
+            return undefined;
+        }
+        const candidates = [];
+        for (const member of type.types) {
+            if (!member || member.kind !== "tupleType") {
+                return undefined;
+            }
+            candidates.push(member.elementTypes);
+        }
+        return candidates;
+    };
+    const tryEmitTupleRestArguments = (startIndex, parameterType) => {
+        const remainingArgs = args.slice(startIndex);
+        if (remainingArgs.some((arg) => arg?.kind === "spread")) {
+            return undefined;
+        }
+        const tupleCandidates = extractTupleRestCandidates(parameterType);
+        if (!tupleCandidates || tupleCandidates.length === 0) {
+            return undefined;
+        }
+        const matchingCandidates = tupleCandidates.filter((candidate) => candidate.length === remainingArgs.length);
+        if (matchingCandidates.length !== 1) {
+            return undefined;
+        }
+        const tupleElements = matchingCandidates[0] ?? [];
+        const emittedArgs = [];
+        let tupleContext = currentContext;
+        for (let index = 0; index < remainingArgs.length; index++) {
+            const arg = remainingArgs[index];
+            const expectedType = tupleElements[index];
+            if (!arg)
+                continue;
+            const [argAst, argContext] = emitExpressionAst(arg, tupleContext, expectedType);
+            emittedArgs.push(argAst);
+            tupleContext = argContext;
+        }
+        return [emittedArgs, tupleContext];
+    };
+    for (let i = 0; i < parameters.length; i++) {
+        const parameter = parameters[i];
+        if (!parameter)
+            continue;
+        if (parameter.isRest) {
+            const tupleRestResult = tryEmitTupleRestArguments(i, parameter.type);
+            if (tupleRestResult) {
+                const [tupleArgs, tupleContext] = tupleRestResult;
+                argAsts.push(...tupleArgs);
+                currentContext = tupleContext;
+                break;
+            }
+            const spreadArg = args[i];
+            if (args.length === i + 1 && spreadArg && spreadArg.kind === "spread") {
+                const [spreadAst, spreadCtx] = emitExpressionAst(spreadArg.expression, currentContext);
+                argAsts.push(spreadAst);
+                currentContext = spreadCtx;
+                break;
+            }
+            const restElementType = parameter.type?.kind === "arrayType"
+                ? parameter.type.elementType
+                : undefined;
+            let elementTypeAst = {
+                kind: "identifierType",
+                name: "object",
+            };
+            if (restElementType) {
+                const [emittedType, typeCtx] = emitTypeAst(restElementType, currentContext);
+                elementTypeAst = emittedType;
+                currentContext = typeCtx;
+            }
+            const restItems = [];
+            for (let j = i; j < args.length; j++) {
+                const arg = args[j];
+                if (!arg)
+                    continue;
+                if (arg.kind === "spread") {
+                    const [spreadAst, spreadCtx] = emitExpressionAst(arg.expression, currentContext);
+                    argAsts.push(spreadAst);
+                    currentContext = spreadCtx;
+                    return [argAsts, currentContext];
+                }
+                const [argAst, argCtx] = emitExpressionAst(arg, currentContext, restElementType);
+                restItems.push(argAst);
+                currentContext = argCtx;
+            }
+            argAsts.push({
+                kind: "arrayCreationExpression",
+                elementType: elementTypeAst,
+                initializer: restItems,
+            });
+            break;
+        }
+        const arg = args[i];
+        if (arg) {
+            const [argAst, argCtx] = emitExpressionAst(arg, currentContext, parameter.type);
+            const modifier = expr.argumentPassing?.[i] &&
+                expr.argumentPassing[i] !== "value" &&
+                isLValue(arg)
+                ? expr.argumentPassing[i]
+                : undefined;
+            argAsts.push(wrapArgModifier(modifier, argAst));
+            currentContext = argCtx;
+            continue;
+        }
+        if (parameter.isOptional || parameter.initializer) {
+            let defaultType;
+            if (parameter.type) {
+                const [emittedType, typeCtx] = emitTypeAst(parameter.type, currentContext);
+                currentContext = typeCtx;
+                defaultType =
+                    parameter.isOptional || parameter.initializer
+                        ? emittedType.kind === "nullableType"
+                            ? emittedType
+                            : { kind: "nullableType", underlyingType: emittedType }
+                        : emittedType;
+            }
+            argAsts.push({ kind: "defaultExpression", type: defaultType });
+        }
+    }
+    return [argAsts, currentContext];
+};
+const isArrayLikeIrType = (type) => {
+    if (!type)
+        return false;
+    if (type.kind === "arrayType" || type.kind === "tupleType") {
+        return true;
+    }
+    if (type.kind === "unionType") {
+        return type.types.every((member) => isArrayLikeIrType(member));
+    }
+    if (type.kind !== "referenceType") {
+        return false;
+    }
+    const simpleName = type.name.split(".").pop() ?? type.name;
+    return (simpleName === "Array" ||
+        simpleName === "ReadonlyArray" ||
+        simpleName === "JSArray" ||
+        simpleName === "Iterable" ||
+        simpleName === "IterableIterator" ||
+        simpleName === "IEnumerable" ||
+        simpleName === "IReadOnlyList" ||
+        simpleName === "List");
+};
+const detectRestParameterInfo = (args, parameterTypes) => {
+    if (parameterTypes.length === 0) {
+        return undefined;
+    }
+    const index = parameterTypes.length - 1;
+    const lastParamType = parameterTypes[index];
+    if (!lastParamType || lastParamType.kind !== "arrayType") {
+        return undefined;
+    }
+    if (args.length > parameterTypes.length) {
+        return {
+            index,
+            arrayType: lastParamType,
+            elementType: lastParamType.elementType,
+        };
+    }
+    const restArgs = args.slice(index);
+    if (restArgs.some((arg) => arg?.kind === "spread")) {
+        return {
+            index,
+            arrayType: lastParamType,
+            elementType: lastParamType.elementType,
+        };
+    }
+    const lastArg = args[index];
+    if (!lastArg) {
+        return undefined;
+    }
+    const lastArgType = lastArg.kind === "spread"
+        ? lastArg.expression.inferredType
+        : lastArg.inferredType;
+    if (!isArrayLikeIrType(lastArgType)) {
+        return {
+            index,
+            arrayType: lastParamType,
+            elementType: lastParamType.elementType,
+        };
+    }
+    return undefined;
+};
+const emitFlattenedRestArguments = (restArgs, restElementType, context) => {
+    let currentContext = context;
+    const [elementTypeAst, typeContext] = emitTypeAst(restElementType, currentContext);
+    currentContext = typeContext;
+    const segments = [];
+    let inlineElements = [];
+    const flushInlineElements = () => {
+        if (inlineElements.length === 0)
+            return;
+        segments.push({
+            kind: "arrayCreationExpression",
+            elementType: elementTypeAst,
+            initializer: inlineElements,
+        });
+        inlineElements = [];
+    };
+    for (const arg of restArgs) {
+        if (!arg)
+            continue;
+        if (arg.kind === "spread") {
+            flushInlineElements();
+            const [spreadAst, spreadContext] = emitExpressionAst(arg.expression, currentContext);
+            segments.push(spreadAst);
+            currentContext = spreadContext;
+            continue;
+        }
+        const [argAst, argContext] = emitExpressionAst(arg, currentContext, restElementType);
+        inlineElements.push(argAst);
+        currentContext = argContext;
+    }
+    flushInlineElements();
+    if (segments.length === 0) {
+        return [
+            [
+                {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "global::System.Array.Empty",
+                    },
+                    typeArguments: [elementTypeAst],
+                    arguments: [],
+                },
+            ],
+            currentContext,
+        ];
+    }
+    let concatAst = segments[0];
+    for (let index = 1; index < segments.length; index++) {
+        concatAst = {
+            kind: "invocationExpression",
+            expression: {
+                kind: "identifierExpression",
+                identifier: "global::System.Linq.Enumerable.Concat",
+            },
+            arguments: [concatAst, segments[index]],
+        };
+    }
+    return [
+        [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::System.Linq.Enumerable.ToArray",
+                },
+                arguments: [concatAst],
+            },
+        ],
+        currentContext,
+    ];
+};
+const stableIrTypeKey = (type) => JSON.stringify(type);
+const unwrapAsyncWrapperIrType = (type) => {
+    if (type.kind !== "referenceType")
+        return undefined;
+    if (!type.typeArguments || type.typeArguments.length !== 1)
+        return undefined;
+    const inner = type.typeArguments[0];
+    if (!inner)
+        return undefined;
+    const simpleName = type.name.split(".").pop() ?? type.name;
+    const clrName = type.resolvedClrType ?? type.name;
+    const isAsyncWrapper = simpleName === "Promise" ||
+        simpleName === "PromiseLike" ||
+        simpleName === "Task_1" ||
+        simpleName === "Task`1" ||
+        simpleName === "ValueTask_1" ||
+        simpleName === "ValueTask`1" ||
+        clrName === "System.Threading.Tasks.Task" ||
+        clrName === "System.Threading.Tasks.ValueTask" ||
+        clrName.startsWith("System.Threading.Tasks.Task`1") ||
+        clrName.startsWith("System.Threading.Tasks.ValueTask`1");
+    return isAsyncWrapper ? inner : undefined;
+};
+const isAsyncWrapperIrTypeLike = (type) => {
+    if (type.kind !== "referenceType")
+        return false;
+    const simpleName = type.name.split(".").pop() ?? type.name;
+    const clrName = type.resolvedClrType ?? type.name;
+    return (simpleName === "Promise" ||
+        simpleName === "PromiseLike" ||
+        simpleName === "Task" ||
+        simpleName === "Task_1" ||
+        simpleName === "Task`1" ||
+        simpleName === "ValueTask" ||
+        simpleName === "ValueTask_1" ||
+        simpleName === "ValueTask`1" ||
+        clrName === "System.Threading.Tasks.Task" ||
+        clrName === "System.Threading.Tasks.ValueTask" ||
+        clrName.startsWith("System.Threading.Tasks.Task`1") ||
+        clrName.startsWith("System.Threading.Tasks.ValueTask`1"));
+};
+const containsPromiseChainArtifact = (type) => {
+    if (!type)
+        return false;
+    if (isAsyncWrapperIrTypeLike(type)) {
+        return true;
+    }
+    if (type.kind === "unionType" || type.kind === "intersectionType") {
+        return type.types.some((member) => !!member && containsPromiseChainArtifact(member));
+    }
+    return false;
+};
+const normalizePromiseChainResultIrType = (type) => {
+    if (!type)
+        return undefined;
+    const asyncInner = unwrapAsyncWrapperIrType(type);
+    if (asyncInner) {
+        return normalizePromiseChainResultIrType(asyncInner);
+    }
+    if (type.kind === "unionType") {
+        const normalizedTypes = [];
+        const seen = new Set();
+        for (const member of type.types) {
+            if (!member)
+                continue;
+            const normalized = normalizePromiseChainResultIrType(member);
+            if (!normalized)
+                continue;
+            const key = stableIrTypeKey(normalized);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            normalizedTypes.push(normalized);
+        }
+        if (normalizedTypes.length === 0)
+            return undefined;
+        if (normalizedTypes.length === 1)
+            return normalizedTypes[0];
+        return {
+            kind: "unionType",
+            types: normalizedTypes,
+        };
+    }
+    return type;
+};
+const mergePromiseChainResultIrTypes = (...types) => {
+    const merged = [];
+    const seen = new Set();
+    for (const type of types) {
+        const normalized = normalizePromiseChainResultIrType(type);
+        if (!normalized)
+            continue;
+        if (normalized.kind === "unionType") {
+            for (const member of normalized.types) {
+                if (!member)
+                    continue;
+                const key = stableIrTypeKey(member);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                merged.push(member);
+            }
+            continue;
+        }
+        const key = stableIrTypeKey(normalized);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(normalized);
+    }
+    if (merged.length === 0)
+        return undefined;
+    if (merged.length === 1)
+        return merged[0];
+    return {
+        kind: "unionType",
+        types: merged,
+    };
+};
+const buildTaskTypeAst = (resultType) => resultType
+    ? {
+        kind: "identifierType",
+        name: "global::System.Threading.Tasks.Task",
+        typeArguments: [resultType],
+    }
+    : {
+        kind: "identifierType",
+        name: "global::System.Threading.Tasks.Task",
+    };
+const buildTaskRunInvocation = (outputTaskType, body, isAsync) => {
+    const resultType = getTaskResultType(outputTaskType);
+    return {
+        kind: "invocationExpression",
+        expression: {
+            kind: "memberAccessExpression",
+            expression: {
+                kind: "identifierExpression",
+                identifier: "global::System.Threading.Tasks.Task",
+            },
+            memberName: "Run",
+        },
+        arguments: [
+            {
+                kind: "lambdaExpression",
+                isAsync,
+                parameters: [],
+                body,
+            },
+        ],
+        typeArguments: resultType ? [resultType] : undefined,
+    };
+};
+const buildCompletedTaskAst = () => ({
+    kind: "memberAccessExpression",
+    expression: {
+        kind: "identifierExpression",
+        identifier: "global::System.Threading.Tasks.Task",
+    },
+    memberName: "CompletedTask",
+});
+const buildPromiseRejectedExceptionAst = (reasonAst) => {
+    const reasonExpr = reasonAst ??
+        {
+            kind: "literalExpression",
+            text: "null",
+        };
+    return {
+        kind: "binaryExpression",
+        operatorToken: "??",
+        left: {
+            kind: "asExpression",
+            expression: reasonExpr,
+            type: {
+                kind: "identifierType",
+                name: "global::System.Exception",
+            },
+        },
+        right: {
+            kind: "objectCreationExpression",
+            type: {
+                kind: "identifierType",
+                name: "global::System.Exception",
+            },
+            arguments: [
+                {
+                    kind: "binaryExpression",
+                    operatorToken: "??",
+                    left: {
+                        kind: "invocationExpression",
+                        expression: {
+                            kind: "conditionalMemberAccessExpression",
+                            expression: reasonExpr,
+                            memberName: "ToString",
+                        },
+                        arguments: [],
+                    },
+                    right: {
+                        kind: "literalExpression",
+                        text: '"Promise rejected"',
+                    },
+                },
+            ],
+        },
+    };
+};
+const getPromiseStaticMethod = (expr) => {
+    if (expr.callee.kind !== "memberAccess")
+        return undefined;
+    if (expr.callee.isComputed)
+        return undefined;
+    if (typeof expr.callee.property !== "string")
+        return undefined;
+    if (expr.callee.object.kind !== "identifier")
+        return undefined;
+    const objectName = expr.callee.object.originalName ?? expr.callee.object.name;
+    const simpleObjectName = objectName.split(".").pop() ?? objectName;
+    if (simpleObjectName !== "Promise")
+        return undefined;
+    switch (expr.callee.property) {
+        case "resolve":
+        case "reject":
+        case "all":
+        case "race":
+            return expr.callee.property;
+        default:
+            return undefined;
+    }
+};
+const getSequenceElementIrType = (type) => {
+    if (!type)
+        return undefined;
+    if (type.kind === "arrayType")
+        return type.elementType;
+    if (type.kind === "tupleType") {
+        if (type.elementTypes.length === 0)
+            return undefined;
+        if (type.elementTypes.length === 1)
+            return type.elementTypes[0];
+        return { kind: "unionType", types: type.elementTypes };
+    }
+    if (type.kind === "referenceType" &&
+        type.typeArguments &&
+        type.typeArguments.length > 0) {
+        const simpleName = type.name.split(".").pop() ?? type.name;
+        switch (simpleName) {
+            case "Array":
+            case "ReadonlyArray":
+            case "Iterable":
+            case "IterableIterator":
+            case "IEnumerable":
+            case "IReadOnlyList":
+            case "List":
+            case "Set":
+            case "ReadonlySet":
+            case "JSArray":
+                return type.typeArguments[0];
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+};
+const isValueTaskLikeIrType = (type) => {
+    if (!type || type.kind !== "referenceType")
+        return false;
+    const simpleName = type.name.split(".").pop() ?? type.name;
+    const clrName = type.resolvedClrType ?? type.name;
+    return (simpleName === "ValueTask" ||
+        simpleName === "ValueTask_1" ||
+        simpleName === "ValueTask`1" ||
+        clrName === "System.Threading.Tasks.ValueTask" ||
+        clrName.startsWith("System.Threading.Tasks.ValueTask`1"));
+};
+const emitPromiseNormalizedTaskAst = (valueAst, valueType, resultTypeAst, context) => {
+    let currentContext = context;
+    const asyncInner = valueType
+        ? unwrapAsyncWrapperIrType(valueType)
+        : undefined;
+    if (asyncInner) {
+        if (isValueTaskLikeIrType(valueType)) {
+            return [
+                {
+                    kind: "invocationExpression",
+                    expression: {
+                        kind: "memberAccessExpression",
+                        expression: valueAst,
+                        memberName: "AsTask",
+                    },
+                    arguments: [],
+                },
+                currentContext,
+            ];
+        }
+        return [valueAst, currentContext];
+    }
+    if (valueType?.kind === "unionType") {
+        const arms = [];
+        for (let index = 0; index < valueType.types.length; index++) {
+            const memberType = valueType.types[index];
+            if (!memberType)
+                continue;
+            const [memberTypeAst, memberTypeContext] = emitTypeAst(memberType, currentContext);
+            currentContext = memberTypeContext;
+            const memberName = `__tsonic_promise_value_${index}`;
+            const [normalizedArm, normalizedContext] = emitPromiseNormalizedTaskAst({
+                kind: "identifierExpression",
+                identifier: memberName,
+            }, memberType, resultTypeAst, currentContext);
+            currentContext = normalizedContext;
+            arms.push({
+                kind: "lambdaExpression",
+                isAsync: false,
+                parameters: [{ name: memberName, type: memberTypeAst }],
+                body: normalizedArm,
+            });
+        }
+        return [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: valueAst,
+                    memberName: "Match",
+                },
+                arguments: arms,
+            },
+            currentContext,
+        ];
+    }
+    if (!resultTypeAst) {
+        return [buildCompletedTaskAst(), currentContext];
+    }
+    return [
+        {
+            kind: "invocationExpression",
+            expression: {
+                kind: "memberAccessExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::System.Threading.Tasks.Task",
+                },
+                memberName: "FromResult",
+            },
+            typeArguments: [resultTypeAst],
+            arguments: [valueAst],
+        },
+        currentContext,
+    ];
 };
-const isVoidOrUnknownIrType = (type) => type === undefined ||
-    type.kind === "voidType" ||
-    type.kind === "unknownType" ||
-    (type.kind === "primitiveType" && type.name === "undefined");
-const getCallbackReturnType = (callbackExpr) => {
-    const declared = callbackExpr.inferredType?.kind === "functionType"
-        ? callbackExpr.inferredType.returnType
-        : undefined;
-    if (!isVoidOrUnknownIrType(declared)) {
-        return declared;
+const emitPromiseStaticCall = (expr, context) => {
+    const method = getPromiseStaticMethod(expr);
+    if (!method)
+        return null;
+    let currentContext = context;
+    const [outputTaskType, outputTaskContext] = emitTypeAst(expr.inferredType ?? {
+        kind: "referenceType",
+        name: "Promise",
+        typeArguments: [{ kind: "referenceType", name: "object" }],
+    }, currentContext);
+    currentContext = outputTaskContext;
+    const outputResultType = getTaskResultType(outputTaskType);
+    if (method === "resolve") {
+        const argument = expr.arguments[0];
+        if (!argument) {
+            return [buildCompletedTaskAst(), currentContext];
+        }
+        const [valueAst, valueContext] = emitExpressionAst(argument, currentContext, argument.inferredType);
+        currentContext = valueContext;
+        return emitPromiseNormalizedTaskAst(valueAst, argument.inferredType, outputResultType, currentContext);
     }
-    if (callbackExpr.kind === "arrowFunction" &&
-        callbackExpr.body.kind !== "blockStatement") {
-        return callbackExpr.body.inferredType;
+    if (method === "reject") {
+        const reason = expr.arguments[0];
+        let reasonAst;
+        if (reason) {
+            [reasonAst, currentContext] = emitExpressionAst(reason, currentContext, reason.inferredType);
+        }
+        const exceptionAst = buildPromiseRejectedExceptionAst(reasonAst);
+        return [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "global::System.Threading.Tasks.Task",
+                    },
+                    memberName: "FromException",
+                },
+                typeArguments: outputResultType ? [outputResultType] : undefined,
+                arguments: [exceptionAst],
+            },
+            currentContext,
+        ];
     }
-    return undefined;
-};
-const buildPromiseChainTaskRun = (outputTaskType, body) => {
-    const resultType = getTaskResultType(outputTaskType);
-    return {
+    const valuesArg = expr.arguments[0];
+    if (!valuesArg)
+        return null;
+    const [valuesAst, valuesContext] = emitExpressionAst(valuesArg, currentContext, valuesArg.inferredType);
+    currentContext = valuesContext;
+    const inputElementType = getSequenceElementIrType(valuesArg.inferredType);
+    const resultElementTypeAst = outputResultType?.kind === "arrayType"
+        ? outputResultType.elementType
+        : outputResultType;
+    let normalizedValuesAst = valuesAst;
+    if (inputElementType) {
+        const [inputElementTypeAst, inputElementContext] = emitTypeAst(inputElementType, currentContext);
+        currentContext = inputElementContext;
+        const [normalizedTaskAst, normalizedTaskContext] = emitPromiseNormalizedTaskAst({
+            kind: "identifierExpression",
+            identifier: "__tsonic_promise_item",
+        }, inputElementType, resultElementTypeAst, currentContext);
+        currentContext = normalizedTaskContext;
+        normalizedValuesAst = {
+            kind: "invocationExpression",
+            expression: {
+                kind: "identifierExpression",
+                identifier: "global::System.Linq.Enumerable.Select",
+            },
+            arguments: [
+                valuesAst,
+                {
+                    kind: "lambdaExpression",
+                    isAsync: false,
+                    parameters: [
+                        {
+                            name: "__tsonic_promise_item",
+                            type: inputElementTypeAst,
+                        },
+                    ],
+                    body: normalizedTaskAst,
+                },
+            ],
+        };
+    }
+    if (method === "all") {
+        return [
+            {
+                kind: "invocationExpression",
+                expression: {
+                    kind: "memberAccessExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "global::System.Threading.Tasks.Task",
+                    },
+                    memberName: "WhenAll",
+                },
+                arguments: [normalizedValuesAst],
+            },
+            currentContext,
+        ];
+    }
+    const whenAnyAst = {
         kind: "invocationExpression",
         expression: {
             kind: "memberAccessExpression",
@@ -211,18 +1222,48 @@ const buildPromiseChainTaskRun = (outputTaskType, body) => {
                 kind: "identifierExpression",
                 identifier: "global::System.Threading.Tasks.Task",
             },
-            memberName: "Run",
+            memberName: "WhenAny",
         },
-        arguments: [
-            {
-                kind: "lambdaExpression",
-                isAsync: true,
-                parameters: [],
-                body,
-            },
-        ],
-        typeArguments: resultType ? [resultType] : undefined,
+        arguments: [normalizedValuesAst],
     };
+    if (!outputResultType) {
+        return [
+            buildTaskRunInvocation(outputTaskType, {
+                kind: "blockStatement",
+                statements: [
+                    {
+                        kind: "expressionStatement",
+                        expression: {
+                            kind: "awaitExpression",
+                            expression: {
+                                kind: "awaitExpression",
+                                expression: whenAnyAst,
+                            },
+                        },
+                    },
+                ],
+            }, true),
+            currentContext,
+        ];
+    }
+    return [
+        buildTaskRunInvocation(outputTaskType, {
+            kind: "blockStatement",
+            statements: [
+                {
+                    kind: "returnStatement",
+                    expression: {
+                        kind: "awaitExpression",
+                        expression: {
+                            kind: "awaitExpression",
+                            expression: whenAnyAst,
+                        },
+                    },
+                },
+            ],
+        }, true),
+        currentContext,
+    ];
 };
 const getDynamicImportSpecifier = (expr) => {
     const [arg] = expr.arguments;
@@ -232,93 +1273,145 @@ const getDynamicImportSpecifier = (expr) => {
         ? arg.value
         : undefined;
 };
-const emitDynamicImportSideEffect = (expr, context) => {
-    if (expr.callee.kind !== "identifier" || expr.callee.name !== "import") {
-        return null;
-    }
-    const specifier = getDynamicImportSpecifier(expr);
-    if (!specifier)
-        return null;
-    const completedTaskExpr = {
-        kind: "memberAccessExpression",
-        expression: {
-            kind: "identifierExpression",
-            identifier: "global::System.Threading.Tasks.Task",
-        },
-        memberName: "CompletedTask",
-    };
+const resolveDynamicImportTargetModule = (specifier, context) => {
     const currentFilePath = context.options.currentModuleFilePath;
     const moduleMap = context.options.moduleMap;
     if (!currentFilePath || !moduleMap) {
-        return [completedTaskExpr, context];
+        return undefined;
     }
     const targetPath = resolveImportPath(currentFilePath, specifier);
-    const targetModule = (() => {
-        const direct = moduleMap.get(targetPath);
-        if (direct)
-            return direct;
-        const normalizedTarget = targetPath.replace(/\\/g, "/");
-        for (const [key, identity] of moduleMap.entries()) {
-            const normalizedKey = key.replace(/\\/g, "/");
-            if (normalizedKey === normalizedTarget ||
-                normalizedKey.endsWith(`/${normalizedTarget}`) ||
-                normalizedTarget.endsWith(`/${normalizedKey}`)) {
-                return identity;
-            }
+    const direct = moduleMap.get(targetPath);
+    if (direct) {
+        return direct;
+    }
+    const normalizedTarget = targetPath.replace(/\\/g, "/");
+    for (const [key, identity] of moduleMap.entries()) {
+        const normalizedKey = key.replace(/\\/g, "/");
+        if (normalizedKey === normalizedTarget ||
+            normalizedKey.endsWith(`/${normalizedTarget}`) ||
+            normalizedTarget.endsWith(`/${normalizedKey}`)) {
+            return identity;
         }
-        return undefined;
-    })();
-    if (!targetModule) {
-        return [completedTaskExpr, context];
     }
+    return undefined;
+};
+const buildDynamicImportContainerType = (targetModule) => {
     const containerName = targetModule.hasTypeCollision
         ? `${targetModule.className}__Module`
         : targetModule.className;
-    const containerType = {
+    return {
         kind: "identifierType",
         name: `global::${targetModule.namespace}.${containerName}`,
     };
-    const runClassConstructor = {
-        kind: "invocationExpression",
+};
+const buildRunClassConstructorExpression = (containerType) => ({
+    kind: "invocationExpression",
+    expression: {
+        kind: "memberAccessExpression",
         expression: {
+            kind: "identifierExpression",
+            identifier: "global::System.Runtime.CompilerServices.RuntimeHelpers",
+        },
+        memberName: "RunClassConstructor",
+    },
+    arguments: [
+        {
             kind: "memberAccessExpression",
             expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Runtime.CompilerServices.RuntimeHelpers",
+                kind: "typeofExpression",
+                type: containerType,
             },
-            memberName: "RunClassConstructor",
+            memberName: "TypeHandle",
         },
-        arguments: [
+    ],
+});
+const emitDynamicImportCall = (expr, context) => {
+    if (expr.callee.kind !== "identifier" || expr.callee.name !== "import") {
+        return null;
+    }
+    const specifier = getDynamicImportSpecifier(expr);
+    if (!specifier)
+        return null;
+    const completedTaskExpr = {
+        kind: "memberAccessExpression",
+        expression: {
+            kind: "identifierExpression",
+            identifier: "global::System.Threading.Tasks.Task",
+        },
+        memberName: "CompletedTask",
+    };
+    const targetModule = resolveDynamicImportTargetModule(specifier, context);
+    if (!expr.dynamicImportNamespace) {
+        if (!targetModule || !targetModule.hasRuntimeContainer) {
+            return [completedTaskExpr, context];
+        }
+        const containerType = buildDynamicImportContainerType(targetModule);
+        const runClassConstructor = buildRunClassConstructorExpression(containerType);
+        return [
             {
-                kind: "memberAccessExpression",
+                kind: "invocationExpression",
                 expression: {
-                    kind: "typeofExpression",
-                    type: containerType,
+                    kind: "memberAccessExpression",
+                    expression: {
+                        kind: "identifierExpression",
+                        identifier: "global::System.Threading.Tasks.Task",
+                    },
+                    memberName: "Run",
                 },
-                memberName: "TypeHandle",
-            },
-        ],
-    };
-    const taskRun = {
-        kind: "invocationExpression",
-        expression: {
-            kind: "memberAccessExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Threading.Tasks.Task",
+                arguments: [
+                    {
+                        kind: "lambdaExpression",
+                        isAsync: false,
+                        parameters: [],
+                        body: runClassConstructor,
+                    },
+                ],
             },
-            memberName: "Run",
-        },
-        arguments: [
+            context,
+        ];
+    }
+    if (!targetModule) {
+        throw new Error(`ICE: Closed-world dynamic import '${specifier}' was validated as a namespace import but no module identity was available during emission.`);
+    }
+    let currentContext = context;
+    const [outputTaskType, outputTaskContext] = emitTypeAst(expr.inferredType ?? {
+        kind: "referenceType",
+        name: "Promise",
+        typeArguments: [{ kind: "referenceType", name: "object" }],
+    }, currentContext);
+    currentContext = outputTaskContext;
+    const [namespaceAst, namespaceContext] = expr.dynamicImportNamespace.properties.length === 0
+        ? [
             {
-                kind: "lambdaExpression",
-                isAsync: false,
-                parameters: [],
-                body: runClassConstructor,
+                kind: "objectCreationExpression",
+                type: { kind: "identifierType", name: "object" },
+                arguments: [],
             },
-        ],
-    };
-    return [taskRun, context];
+            currentContext,
+        ]
+        : emitExpressionAst(expr.dynamicImportNamespace, currentContext, expr.dynamicImportNamespace.inferredType);
+    currentContext = namespaceContext;
+    const setupStatements = [];
+    if (targetModule.hasRuntimeContainer) {
+        const containerType = buildDynamicImportContainerType(targetModule);
+        setupStatements.push({
+            kind: "expressionStatement",
+            expression: buildRunClassConstructorExpression(containerType),
+        });
+    }
+    return [
+        buildTaskRunInvocation(outputTaskType, {
+            kind: "blockStatement",
+            statements: [
+                ...setupStatements,
+                {
+                    kind: "returnStatement",
+                    expression: namespaceAst,
+                },
+            ],
+        }, false),
+        currentContext,
+    ];
 };
 const emitPromiseThenCatchFinally = (expr, context) => {
     if (expr.callee.kind !== "memberAccess")
@@ -339,7 +1432,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
         : expr.inferredType;
     const [rawOutputTaskType, outputTaskCtx] = emitTypeAst(outputTypeHint ?? { kind: "referenceType", name: "Task" }, currentContext);
     currentContext = outputTaskCtx;
-    const outputTaskType = isTaskTypeAst(rawOutputTaskType) &&
+    const defaultOutputTaskType = isTaskTypeAst(rawOutputTaskType) &&
         rawOutputTaskType.typeArguments?.length === 1 &&
         containsVoidTypeAst(rawOutputTaskType.typeArguments[0])
         ? { kind: "identifierType", name: "global::System.Threading.Tasks.Task" }
@@ -347,7 +1440,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
     const [sourceTaskType, sourceTaskCtx] = emitTypeAst(expr.callee.object.inferredType ?? { kind: "referenceType", name: "Task" }, currentContext);
     currentContext = sourceTaskCtx;
     const sourceResultType = getTaskResultType(sourceTaskType);
-    const outputResultType = getTaskResultType(outputTaskType);
+    const sourceResultIr = normalizePromiseChainResultIrType(expr.callee.object.inferredType);
     const exIdent = "__tsonic_promise_ex";
     const valueIdent = "__tsonic_promise_value";
     const fulfilledArg = expr.arguments[0];
@@ -371,6 +1464,42 @@ const emitPromiseThenCatchFinally = (expr, context) => {
         finallyAst = fiAst;
         currentContext = fiCtx;
     }
+    const fulfilledResultIr = fulfilledArg && fulfilledArg.kind !== "spread"
+        ? normalizePromiseChainResultIrType(getCallbackReturnType(fulfilledArg))
+        : undefined;
+    const rejectedResultIr = rejectedArg && rejectedArg.kind !== "spread"
+        ? normalizePromiseChainResultIrType(getCallbackReturnType(rejectedArg))
+        : undefined;
+    const normalizedPromiseChainResultIr = (() => {
+        if (expr.callee.property === "then") {
+            if (rejectedArg && rejectedArg.kind !== "spread") {
+                return mergePromiseChainResultIrTypes(fulfilledResultIr ?? sourceResultIr, rejectedResultIr);
+            }
+            return fulfilledResultIr ?? sourceResultIr;
+        }
+        if (expr.callee.property === "catch") {
+            return mergePromiseChainResultIrTypes(sourceResultIr, rejectedResultIr);
+        }
+        if (expr.callee.property === "finally") {
+            return sourceResultIr;
+        }
+        return undefined;
+    })();
+    const normalizedFrontendPromiseChainResultIr = normalizePromiseChainResultIrType(expr.inferredType);
+    const preferredPromiseChainResultIr = normalizedFrontendPromiseChainResultIr &&
+        !containsPromiseChainArtifact(normalizedFrontendPromiseChainResultIr)
+        ? normalizedFrontendPromiseChainResultIr
+        : normalizedPromiseChainResultIr;
+    let outputResultType = getTaskResultType(defaultOutputTaskType);
+    let outputTaskType = defaultOutputTaskType;
+    if (preferredPromiseChainResultIr) {
+        const [normalizedResultAst, normalizedCtx] = emitTypeAst(preferredPromiseChainResultIr, currentContext);
+        currentContext = normalizedCtx;
+        outputResultType = containsVoidTypeAst(normalizedResultAst)
+            ? undefined
+            : normalizedResultAst;
+        outputTaskType = buildTaskTypeAst(outputResultType);
+    }
     const awaitReceiverStatement = sourceResultType === undefined
         ? {
             kind: "expressionStatement",
@@ -413,7 +1542,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
             callbackParameterCount(fulfilledArg) > 0
             ? [sourceResultType]
             : [];
-        const callbackReturnIr = getCallbackReturnType(fulfilledArg);
+        const callbackReturnIr = getCallbackDelegateReturnType(fulfilledArg);
         let callbackReturnTypeAst = outputResultType;
         if (callbackReturnIr !== undefined) {
             const [cbRetAst, cbRetCtx] = emitTypeAst(callbackReturnIr, currentContext);
@@ -465,7 +1594,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
                 identifier: exIdent,
             });
         }
-        const callbackReturnIr = getCallbackReturnType(rejectedArg);
+        const callbackReturnIr = getCallbackDelegateReturnType(rejectedArg);
         let callbackReturnTypeAst = outputResultType;
         if (callbackReturnIr !== undefined) {
             const [cbRetAst, cbRetCtx] = emitTypeAst(callbackReturnIr, currentContext);
@@ -509,7 +1638,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
     const invokeFinally = () => {
         if (!finallyAst)
             return [];
-        const callbackReturnIr = getCallbackReturnType(finallyArg);
+        const callbackReturnIr = getCallbackDelegateReturnType(finallyArg);
         let callbackReturnTypeAst = undefined;
         if (callbackReturnIr !== undefined) {
             const [cbRetAst, cbRetCtx] = emitTypeAst(callbackReturnIr, currentContext);
@@ -567,10 +1696,10 @@ const emitPromiseThenCatchFinally = (expr, context) => {
             ]
             : thenStatements;
         return [
-            buildPromiseChainTaskRun(outputTaskType, {
+            buildTaskRunInvocation(outputTaskType, {
                 kind: "blockStatement",
                 statements: bodyStatements,
-            }),
+            }, true),
             currentContext,
         ];
     }
@@ -594,7 +1723,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
             },
         ];
         return [
-            buildPromiseChainTaskRun(outputTaskType, {
+            buildTaskRunInvocation(outputTaskType, {
                 kind: "blockStatement",
                 statements: [
                     {
@@ -603,7 +1732,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
                         catches,
                     },
                 ],
-            }),
+            }, true),
             currentContext,
         ];
     }
@@ -612,7 +1741,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
             ? [{ kind: "expressionStatement", expression: buildAwait(receiverAst) }]
             : [{ kind: "returnStatement", expression: buildAwait(receiverAst) }];
         return [
-            buildPromiseChainTaskRun(outputTaskType, {
+            buildTaskRunInvocation(outputTaskType, {
                 kind: "blockStatement",
                 statements: [
                     {
@@ -625,7 +1754,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
                         },
                     },
                 ],
-            }),
+            }, true),
             currentContext,
         ];
     }
@@ -633,20 +1762,40 @@ const emitPromiseThenCatchFinally = (expr, context) => {
 };
 /**
  * Emit call arguments as typed AST array.
- * Handles spread (params), castModifier (ref/out from cast), and argumentPassing modes.
+ * Handles spread arrays, castModifier (ref/out from cast), and argumentPassing modes.
  */
 const emitCallArguments = (args, expr, context) => {
+    const functionValueSignature = getFunctionValueSignature(expr);
+    if (functionValueSignature &&
+        functionValueSignature.parameters.some((parameter) => parameter?.isRest ||
+            parameter?.isOptional ||
+            parameter?.initializer !== undefined)) {
+        return emitFunctionValueCallArguments(args, functionValueSignature, expr, context);
+    }
     const parameterTypes = expr.parameterTypes ?? [];
+    const restInfo = detectRestParameterInfo(args, parameterTypes);
     let currentContext = context;
     const argAsts = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (!arg)
             continue;
-        const expectedType = parameterTypes[i];
+        if (restInfo &&
+            i === restInfo.index &&
+            args
+                .slice(restInfo.index)
+                .some((candidate) => candidate?.kind === "spread")) {
+            const [flattenedRestArgs, flattenedContext] = emitFlattenedRestArguments(args.slice(restInfo.index), restInfo.elementType, currentContext);
+            argAsts.push(...flattenedRestArgs);
+            currentContext = flattenedContext;
+            break;
+        }
+        const expectedType = restInfo && i >= restInfo.index
+            ? restInfo.elementType
+            : parameterTypes[i];
         if (arg.kind === "spread") {
             const [spreadAst, ctx] = emitExpressionAst(arg.expression, currentContext);
-            argAsts.push(wrapArgModifier("params", spreadAst));
+            argAsts.push(spreadAst);
             currentContext = ctx;
         }
         else {
@@ -672,7 +1821,52 @@ const emitCallArguments = (args, expr, context) => {
 /**
  * Emit a JsonSerializer call with NativeAOT-compatible options.
  */
-const emitJsonSerializerCall = (expr, context, method) => {
+const isConcreteGlobalJsonParseTarget = (type) => {
+    if (!type)
+        return false;
+    if (type.kind === "unknownType" ||
+        type.kind === "anyType" ||
+        type.kind === "voidType" ||
+        type.kind === "neverType") {
+        return false;
+    }
+    if (type.kind === "unionType" || type.kind === "intersectionType") {
+        return false;
+    }
+    return !containsTypeParameter(type);
+};
+const emitJsRuntimeJsonParseCall = (expr, context, typeArgument) => {
+    let currentContext = context;
+    const argAsts = [];
+    for (const arg of expr.arguments) {
+        if (arg.kind === "spread") {
+            const [spreadAst, ctx] = emitExpressionAst(arg.expression, currentContext);
+            argAsts.push(spreadAst);
+            currentContext = ctx;
+            continue;
+        }
+        const [argAst, ctx] = emitExpressionAst(arg, currentContext);
+        argAsts.push(argAst);
+        currentContext = ctx;
+    }
+    return [
+        {
+            kind: "invocationExpression",
+            expression: {
+                kind: "memberAccessExpression",
+                expression: {
+                    kind: "identifierExpression",
+                    identifier: "global::Tsonic.JSRuntime.JSON",
+                },
+                memberName: "parse",
+            },
+            arguments: argAsts,
+            typeArguments: [typeArgument],
+        },
+        currentContext,
+    ];
+};
+const emitJsonSerializerCall = (expr, context, method, deserializeTypeOverride) => {
     let currentContext = context;
     // Register the type with the JSON AOT registry
     if (method === "Serialize") {
@@ -682,14 +1876,22 @@ const emitJsonSerializerCall = (expr, context, method) => {
         }
     }
     else {
-        const typeArg = expr.typeArguments?.[0];
+        const typeArg = deserializeTypeOverride ?? expr.typeArguments?.[0];
         if (typeArg) {
             registerJsonAotType(typeArg, context);
         }
     }
     // Emit type arguments for Deserialize<T>
     let typeArgAsts = [];
-    if (expr.typeArguments && expr.typeArguments.length > 0) {
+    const deserializeIrType = method === "Deserialize"
+        ? (deserializeTypeOverride ?? expr.typeArguments?.[0])
+        : undefined;
+    if (deserializeIrType) {
+        const [typeArgs, typeContext] = emitTypeArgumentsAst([deserializeIrType], currentContext);
+        typeArgAsts = typeArgs;
+        currentContext = typeContext;
+    }
+    else if (expr.typeArguments && expr.typeArguments.length > 0) {
         const [typeArgs, typeContext] = emitTypeArgumentsAst(expr.typeArguments, currentContext);
         typeArgAsts = typeArgs;
         currentContext = typeContext;
@@ -708,8 +1910,11 @@ const emitJsonSerializerCall = (expr, context, method) => {
             currentContext = ctx;
         }
     }
-    // Add TsonicJson.Options when NativeAOT JSON context generation is enabled.
-    if (context.options.jsonAotRegistry) {
+    // Only pass TsonicJson.Options when this call site actually participates in the
+    // NativeAOT JSON rewrite. Non-generic JSON.parse(...) intentionally returns
+    // unknown and should emit plain JsonSerializer calls without requiring the
+    // generated TsonicJson helper.
+    if (context.options.jsonAotRegistry?.needsJsonAot) {
         argAsts.push({
             kind: "identifierExpression",
             identifier: "TsonicJson.Options",
@@ -730,13 +1935,32 @@ const emitJsonSerializerCall = (expr, context, method) => {
     };
     return [invocation, currentContext];
 };
+const emitGlobalJsonCall = (expr, context, method) => {
+    if (method === "Serialize") {
+        return emitJsonSerializerCall(expr, context, method);
+    }
+    const deserializeTarget = expr.typeArguments?.[0] ??
+        (isConcreteGlobalJsonParseTarget(expr.inferredType)
+            ? expr.inferredType
+            : undefined);
+    if (deserializeTarget) {
+        return emitJsonSerializerCall(expr, context, "Deserialize", deserializeTarget);
+    }
+    return emitJsRuntimeJsonParseCall(expr, context, {
+        kind: "predefinedType",
+        keyword: "object",
+    });
+};
 /**
  * Emit a function call expression as CSharpExpressionAst
  */
 export const emitCall = (expr, context) => {
-    const dynamicImport = emitDynamicImportSideEffect(expr, context);
+    const dynamicImport = emitDynamicImportCall(expr, context);
     if (dynamicImport)
         return dynamicImport;
+    const promiseStaticCall = emitPromiseStaticCall(expr, context);
+    if (promiseStaticCall)
+        return promiseStaticCall;
     const promiseChain = emitPromiseThenCatchFinally(expr, context);
     if (promiseChain)
         return promiseChain;
@@ -767,7 +1991,7 @@ export const emitCall = (expr, context) => {
     // Check for global JSON.stringify/parse calls
     const globalJsonCall = isGlobalJsonCall(expr.callee);
     if (globalJsonCall) {
-        return emitJsonSerializerCall(expr, context, globalJsonCall.method);
+        return emitGlobalJsonCall(expr, context, globalJsonCall.method);
     }
     // EF Core query canonicalization: ToList().ToArray() → ToArray()
     if (expr.callee.kind === "memberAccess" &&
@@ -892,6 +2116,10 @@ export const emitCall = (expr, context) => {
         ];
     }
     const arrayWrapperInteropCall = emitArrayWrapperInteropCall(expr, context);
+    const arrayMutationInteropCall = emitArrayMutationInteropCall(expr, context);
+    if (arrayMutationInteropCall) {
+        return arrayMutationInteropCall;
+    }
     if (arrayWrapperInteropCall) {
         return arrayWrapperInteropCall;
     }